From 8460f4ab7f3635301a7a36efa3fd8d74c235a670 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 21 Jun 2024 10:46:11 +0200
Subject: [PATCH 001/100] updates templates to re-enable interactive debugging
 of generator

---
 gen_input/templates/CORENAME.cpp.gtl        |   8 +-
 gen_input/templates/CORENAME.h.gtl          |   8 +-
 gen_input/templates/interp/CORENAME.cpp.gtl |   2 +-
 src/iss/arch/tgc5c.h                        |   2 +-
 src/vm/interp/vm_tgc5c.cpp                  | 140 ++++++++++----------
 5 files changed, 80 insertions(+), 80 deletions(-)

diff --git a/gen_input/templates/CORENAME.cpp.gtl b/gen_input/templates/CORENAME.cpp.gtl
index 7925e90..c7a0299 100644
--- a/gen_input/templates/CORENAME.cpp.gtl
+++ b/gen_input/templates/CORENAME.cpp.gtl
@@ -47,10 +47,10 @@ def getRegisterSizes(){
 
 using namespace iss::arch;
 
-constexpr std::array<const char*, ${registers.size}>    iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_names;
-constexpr std::array<const char*, ${registers.size}>    iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_aliases;
-constexpr std::array<const uint32_t, ${getRegisterSizes().size}> iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_bit_widths;
-constexpr std::array<const uint32_t, ${getRegisterSizes().size}> iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_byte_offsets;
+constexpr std::array<const char*, ${registers.size()}>    iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_names;
+constexpr std::array<const char*, ${registers.size()}>    iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_aliases;
+constexpr std::array<const uint32_t, ${getRegisterSizes().size()}> iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_bit_widths;
+constexpr std::array<const uint32_t, ${getRegisterSizes().size()}> iss::arch::traits<iss::arch::${coreDef.name.toLowerCase()}>::reg_byte_offsets;
 
 ${coreDef.name.toLowerCase()}::${coreDef.name.toLowerCase()}()  = default;
 
diff --git a/gen_input/templates/CORENAME.h.gtl b/gen_input/templates/CORENAME.h.gtl
index 02ecb68..f08ce13 100644
--- a/gen_input/templates/CORENAME.h.gtl
+++ b/gen_input/templates/CORENAME.h.gtl
@@ -75,10 +75,10 @@ template <> struct traits<${coreDef.name.toLowerCase()}> {
 
     constexpr static char const* const core_type = "${coreDef.name}";
     
-    static constexpr std::array<const char*, ${registers.size}> reg_names{
+    static constexpr std::array<const char*, ${registers.size()}> reg_names{
         {"${registers.collect{it.name.toLowerCase()}.join('", "')}"}};
  
-    static constexpr std::array<const char*, ${registers.size}> reg_aliases{
+    static constexpr std::array<const char*, ${registers.size()}> reg_aliases{
         {"${registers.collect{it.alias.toLowerCase()}.join('", "')}"}};
 
     enum constants {${constants.collect{c -> c.name+"="+getCString(c.value)}.join(', ')}};
@@ -99,10 +99,10 @@ template <> struct traits<${coreDef.name.toLowerCase()}> {
 
     using phys_addr_t = iss::typed_addr_t<iss::address_type::PHYSICAL>;
 
-    static constexpr std::array<const uint32_t, ${getRegisterSizes().size}> reg_bit_widths{
+    static constexpr std::array<const uint32_t, ${getRegisterSizes().size()}> reg_bit_widths{
         {${getRegisterSizes().join(',')}}};
 
-    static constexpr std::array<const uint32_t, ${getRegisterOffsets().size}> reg_byte_offsets{
+    static constexpr std::array<const uint32_t, ${getRegisterOffsets().size()}> reg_byte_offsets{
         {${getRegisterOffsets().join(',')}}};
 
     static const uint64_t addr_mask = (reg_t(1) << (XLEN - 1)) | ((reg_t(1) << (XLEN - 1)) - 1);
diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index fd2bbc6..01d1cd7 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -160,7 +160,7 @@ private:
     };
 
     decoding_tree_node* root {nullptr};
-    const std::array<instruction_descriptor, ${instructions.size}> instr_descr = {{
+    const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         {${instr.length}, ${instr.encoding}, ${instr.mask}, arch::traits<ARCH>::opcode_e::${instr.instruction.name}},<%}%>
     }};
diff --git a/src/iss/arch/tgc5c.h b/src/iss/arch/tgc5c.h
index cff086d..7d51456 100644
--- a/src/iss/arch/tgc5c.h
+++ b/src/iss/arch/tgc5c.h
@@ -53,7 +53,7 @@ template <> struct traits<tgc5c> {
     static constexpr std::array<const char*, 36> reg_aliases{
         {"zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", "pc", "next_pc", "priv", "dpc"}};
 
-    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
+    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
 
     constexpr static unsigned FP_REGS_SIZE = 0;
 
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index e4a816e..9b6fcb9 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -399,7 +399,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -425,7 +425,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -451,7 +451,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(imm % traits::INSTR_ALIGNMENT) {
@@ -485,7 +485,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t addr_mask = (uint32_t)- 2;
@@ -521,7 +521,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs1) == *(X+rs2)) {
@@ -554,7 +554,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs1) != *(X+rs2)) {
@@ -587,7 +587,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if((int32_t)*(X+rs1) < (int32_t)*(X+rs2)) {
@@ -620,7 +620,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if((int32_t)*(X+rs1) >= (int32_t)*(X+rs2)) {
@@ -653,7 +653,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs1) < *(X+rs2)) {
@@ -686,7 +686,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs1) >= *(X+rs2)) {
@@ -719,7 +719,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -750,7 +750,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -781,7 +781,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -812,7 +812,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -843,7 +843,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -874,7 +874,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t store_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -901,7 +901,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t store_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -928,7 +928,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t store_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
@@ -955,7 +955,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -982,7 +982,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1009,7 +1009,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1036,7 +1036,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1063,7 +1063,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1090,7 +1090,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1117,7 +1117,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1144,7 +1144,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1171,11 +1171,11 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
-                                            *(X+rd) = (uint32_t)((int32_t)*(X+rs1) >> shamt);
+                                            *(X+rd) = ((uint32_t)((int32_t)*(X+rs1) >> shamt));
                                         }
                                     }
                                 }
@@ -1198,7 +1198,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1225,7 +1225,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1252,7 +1252,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1279,7 +1279,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1306,7 +1306,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1333,7 +1333,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1360,7 +1360,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1387,7 +1387,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1414,7 +1414,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1441,7 +1441,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -1542,7 +1542,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t xrs1 = *(X+rs1);
@@ -1579,7 +1579,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t res_33 = super::template read_mem<uint32_t>(traits::CSR, csr);
@@ -1614,7 +1614,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t res_34 = super::template read_mem<uint32_t>(traits::CSR, csr);
@@ -1649,7 +1649,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t res_35 = super::template read_mem<uint32_t>(traits::CSR, csr);
@@ -1681,7 +1681,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t res_36 = super::template read_mem<uint32_t>(traits::CSR, csr);
@@ -1715,7 +1715,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t res_37 = super::template read_mem<uint32_t>(traits::CSR, csr);
@@ -1739,7 +1739,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
                         auto mnemonic = fmt::format(
-                            "{mnemonic:10} {rs1}, {rd}, {imm}", fmt::arg("mnemonic", "fence_i"),
+                            "{mnemonic:10} {rs1}, {rd}, {imm}", fmt::arg("mnemonic", "fence.i"),
                             fmt::arg("rs1", name(rs1)), fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
                         this->core.disass_output(pc.val, mnemonic);
                     }
@@ -1769,7 +1769,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         int64_t res = (int64_t)((int32_t)*(X+rs1) ) * (int64_t)((int32_t)*(X+rs2) );
@@ -1797,7 +1797,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         int64_t res = (int64_t)((int32_t)*(X+rs1) ) * (int64_t)((int32_t)*(X+rs2) );
@@ -1825,7 +1825,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         int64_t res = (int64_t)((int32_t)*(X+rs1) ) * (int64_t)(*(X+rs2) );
@@ -1853,7 +1853,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint64_t res = (uint64_t)(*(X+rs1) ) * (uint64_t)(*(X+rs2) );
@@ -1881,7 +1881,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         int32_t dividend = (int32_t)*(X+rs1);
@@ -1921,7 +1921,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs2) != 0) {
@@ -1955,7 +1955,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs2) != 0) {
@@ -1997,7 +1997,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS || rs1 >= traits::RFS || rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(*(X+rs2) != 0) {
@@ -2033,7 +2033,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         *(X+rd + 8) = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)(imm ));
                                     }
                                     else {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                 }
                     break;
@@ -2099,7 +2099,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rs1 != 0) {
@@ -2113,7 +2113,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     uint8_t nzimm = ((bit_sub<2,5>(instr)) | (bit_sub<12,1>(instr) << 5));
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "c__nop");
+                        this->core.disass_output(pc.val, "c.nop");
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2158,7 +2158,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -2184,7 +2184,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                         if(imm == 0 || rd >= traits::RFS) {
-                            raise(0, 2);
+                            raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                         }
                         if(rd != 0) {
                             *(X+rd) = (uint32_t)((int32_t)sext<18>(imm));
@@ -2210,7 +2210,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         *(X+2) = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)((int16_t)sext<10>(nzimm) ));
                                     }
                                     else {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                 }
                     break;
@@ -2219,13 +2219,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     uint8_t rd = ((bit_sub<7,5>(instr)));
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "__reserved_clui");
+                        this->core.disass_output(pc.val, ".reserved_clui");
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
                     // execute instruction
                     {
-                                    raise(0, 2);
+                                    raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                 }
                     break;
                 }// @suppress("No break at end of case")
@@ -2447,7 +2447,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rs1 != 0) {
@@ -2473,7 +2473,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                         if(rd >= traits::RFS || rd == 0) {
-                            raise(0, 2);
+                            raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                         }
                         else {
                             uint32_t offs = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)(uimm ));
@@ -2500,7 +2500,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -2537,7 +2537,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::__reserved_cmv: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "__reserved_cmv");
+                        this->core.disass_output(pc.val, ".reserved_cmv");
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2563,7 +2563,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rd >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         if(rd != 0) {
@@ -2588,7 +2588,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs1 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t new_pc = *(X+rs1);
@@ -2602,7 +2602,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::C__EBREAK: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "c__ebreak");
+                        this->core.disass_output(pc.val, "c.ebreak");
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2628,7 +2628,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs2 >= traits::RFS) {
-                                        raise(0, 2);
+                                        raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
                                         uint32_t offs = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)(uimm ));
@@ -2647,7 +2647,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     *NEXT_PC = *PC + 2;
                     // execute instruction
                     {
-                                    raise(0, 2);
+                                    raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                 }
                     break;
                 }// @suppress("No break at end of case")

From 2fb28364c53ab65af9620c43f93d58a229d42909 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 21 Jun 2024 10:49:36 +0200
Subject: [PATCH 002/100] fixes remaining templates

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 4 ++--
 gen_input/templates/interp/CORENAME.cpp.gtl | 2 +-
 gen_input/templates/llvm/CORENAME.cpp.gtl   | 4 ++--
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index b671123..6eea65f 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017, 2023 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -129,7 +129,7 @@ private:
 
     decoding_tree_node* root {nullptr};
 
-    const std::array<instruction_descriptor, ${instructions.size}> instr_descr = {{
+    const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>
diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 01d1cd7..373eb55 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2021 MINRES Technologies GmbH
+ * Copyright (C) 20217-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 9bbd147..32ca308 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017, 2018 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -148,7 +148,7 @@ private:
 
     decoding_tree_node* root {nullptr};
 
-    const std::array<instruction_descriptor, ${instructions.size}> instr_descr = {{
+    const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index f9ee677..2a66aea 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2020 MINRES Technologies GmbH
+ * Copyright (C) 2020-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -148,7 +148,7 @@ private:
 
     decoding_tree_node* root {nullptr};
 
-    const std::array<instruction_descriptor, ${instructions.size}> instr_descr = {{
+    const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>

From 482a4ec2537ab58cfd621b1ec0cb5e4b0863d41b Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Fri, 21 Jun 2024 13:35:25 +0200
Subject: [PATCH 003/100] fixes semihosting callbacks in templates

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 4 ++--
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index b671123..9192715 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -363,7 +363,7 @@ volatile std::array<bool, 2> dummy = {
 		    auto vm = new asmjit::${coreDef.name.toLowerCase()}::vm_impl<arch::${coreDef.name.toLowerCase()}>(*cpu, false);
 		    if (port != 0) debugger::server<debugger::gdb_session>::run_server(vm, port);
             if(init_data){
-                auto* cb = reinterpret_cast<std::function<void(arch_if*, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t)>*>(init_data);
+                auto* cb = reinterpret_cast<semihosting_cb_t<arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t>*>(init_data);
                 cpu->set_semihosting_callback(*cb);
             }
             return {cpu_ptr{cpu}, vm_ptr{vm}};
@@ -373,7 +373,7 @@ volatile std::array<bool, 2> dummy = {
 		    auto vm = new asmjit::${coreDef.name.toLowerCase()}::vm_impl<arch::${coreDef.name.toLowerCase()}>(*cpu, false);
 		    if (port != 0) debugger::server<debugger::gdb_session>::run_server(vm, port);
             if(init_data){
-                auto* cb = reinterpret_cast<std::function<void(arch_if*, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t)>*>(init_data);
+                auto* cb = reinterpret_cast<semihosting_cb_t<arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t>*>(init_data);
                 cpu->set_semihosting_callback(*cb);
             }
             return {cpu_ptr{cpu}, vm_ptr{vm}};
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index f9ee677..73add3d 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -334,7 +334,7 @@ volatile std::array<bool, 2> dummy = {
 		    auto vm = new tcc::${coreDef.name.toLowerCase()}::vm_impl<arch::${coreDef.name.toLowerCase()}>(*cpu, false);
 		    if (port != 0) debugger::server<debugger::gdb_session>::run_server(vm, port);
             if(init_data){
-                auto* cb = reinterpret_cast<std::function<void(arch_if*, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t)>*>(init_data);
+                auto* cb = reinterpret_cast<semihosting_cb_t<arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t>*>(init_data);
                 cpu->set_semihosting_callback(*cb);
             }
             return {cpu_ptr{cpu}, vm_ptr{vm}};
@@ -344,7 +344,7 @@ volatile std::array<bool, 2> dummy = {
 		    auto vm = new tcc::${coreDef.name.toLowerCase()}::vm_impl<arch::${coreDef.name.toLowerCase()}>(*cpu, false);
 		    if (port != 0) debugger::server<debugger::gdb_session>::run_server(vm, port);
             if(init_data){
-                auto* cb = reinterpret_cast<std::function<void(arch_if*, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t, arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t)>*>(init_data);
+                auto* cb = reinterpret_cast<semihosting_cb_t<arch::traits<arch::${coreDef.name.toLowerCase()}>::reg_t>*>(init_data);
                 cpu->set_semihosting_callback(*cb);
             }
             return {cpu_ptr{cpu}, vm_ptr{vm}};

From 48370a4555194e26adf8999c69fd503a725b237e Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Sat, 22 Jun 2024 09:28:26 +0200
Subject: [PATCH 004/100] asmjit passes backend with new CoreDSL

---
 src/vm/asmjit/vm_tgc5c.cpp | 189 +++++++++++++++++--------------------
 1 file changed, 89 insertions(+), 100 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index c77b741..d99a50a 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017, 2023 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -339,7 +339,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -385,7 +385,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -431,7 +431,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
@@ -486,7 +486,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto addr_mask = (uint32_t)- 2;
@@ -554,7 +554,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -612,7 +612,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -670,7 +670,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -730,7 +730,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -790,7 +790,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -848,7 +848,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -906,7 +906,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address = gen_ext(jh, 
@@ -959,7 +959,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address = gen_ext(jh, 
@@ -1012,7 +1012,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address = gen_ext(jh, 
@@ -1065,7 +1065,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address = gen_ext(jh, 
@@ -1117,7 +1117,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address = gen_ext(jh, 
@@ -1169,7 +1169,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address = gen_ext(jh, 
@@ -1217,7 +1217,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address = gen_ext(jh, 
@@ -1265,7 +1265,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address = gen_ext(jh, 
@@ -1313,7 +1313,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1362,7 +1362,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1424,7 +1424,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1485,7 +1485,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1533,7 +1533,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1581,7 +1581,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1629,7 +1629,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1677,7 +1677,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1725,7 +1725,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1733,7 +1733,7 @@ private:
                      gen_ext(jh, 
                          (gen_operation(jh, sar, gen_ext(jh, 
                              load_reg_from_mem(jh, traits::X0 + rs1), 32, true), shamt)
-                         ), 32, true));
+                         ), 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1775,7 +1775,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1824,7 +1824,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1873,7 +1873,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1922,7 +1922,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -1985,7 +1985,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2046,7 +2046,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2094,7 +2094,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2143,7 +2143,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2194,7 +2194,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2242,7 +2242,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -2471,7 +2471,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrs1 = load_reg_from_mem(jh, traits::X0 + rs1);
@@ -2524,7 +2524,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
@@ -2577,7 +2577,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
@@ -2630,7 +2630,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
@@ -2679,7 +2679,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
@@ -2731,7 +2731,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
@@ -2822,16 +2822,13 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_ext(jh, 
-                (gen_operation(jh, imul, gen_ext(jh, 
-                    gen_ext(jh, 
-                        load_reg_from_mem(jh, traits::X0 + rs1), 32, true), 64, true), gen_ext(jh, 
-                    gen_ext(jh, 
-                        load_reg_from_mem(jh, traits::X0 + rs2), 32, true), 64, true))
-                ), 64, true);
+            auto res = gen_operation(jh, imul, gen_ext(jh, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
+            ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
                      gen_ext(jh, 
@@ -2877,16 +2874,13 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_ext(jh, 
-                (gen_operation(jh, imul, gen_ext(jh, 
-                    gen_ext(jh, 
-                        load_reg_from_mem(jh, traits::X0 + rs1), 32, true), 64, true), gen_ext(jh, 
-                    gen_ext(jh, 
-                        load_reg_from_mem(jh, traits::X0 + rs2), 32, true), 64, true))
-                ), 64, true);
+            auto res = gen_operation(jh, imul, gen_ext(jh, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
+            ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
                      gen_ext(jh, 
@@ -2933,15 +2927,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_ext(jh, 
-                (gen_operation(jh, imul, gen_ext(jh, 
-                    gen_ext(jh, 
-                        load_reg_from_mem(jh, traits::X0 + rs1), 32, true), 64, true), gen_ext(jh, 
-                    load_reg_from_mem(jh, traits::X0 + rs2), 64, false))
-                ), 64, true);
+            auto res = gen_operation(jh, imul, gen_ext(jh, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), load_reg_from_mem(jh, traits::X0 + rs2))
+            ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
                      gen_ext(jh, 
@@ -2988,14 +2979,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_ext(jh, 
-                (gen_operation(jh, mul, gen_ext(jh, 
-                    load_reg_from_mem(jh, traits::X0 + rs1), 64, false), gen_ext(jh, 
-                    load_reg_from_mem(jh, traits::X0 + rs2), 64, false))
-                ), 64, false);
+            auto res = gen_operation(jh, mul,
+                load_reg_from_mem(jh, traits::X0 + rs1),
+                load_reg_from_mem(jh, traits::X0 + rs2));
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
                      gen_ext(jh, 
@@ -3042,13 +3031,13 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto dividend = gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs1), 32, false);
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true);
             auto divisor = gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs2), 32, false);
+                load_reg_from_mem(jh, traits::X0 + rs2), 32, true);
             if(rd!=0){
                 auto label_merge = cc.newLabel();
                 cc.cmp(gen_operation(jh, ne, divisor, 0)
@@ -3126,7 +3115,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -3137,9 +3126,8 @@ private:
             {
                 if(rd!=0){
                     cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                         gen_ext(jh, 
-                             (gen_operation(jh, div, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                             ), 32, false));
+                         gen_operation(jh, div, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                         );
                 }
             }
             cc.jmp(label_merge);
@@ -3191,7 +3179,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -3223,9 +3211,9 @@ private:
                             cc.mov(get_ptr_for(jh, traits::X0+ rd),
                                  gen_ext(jh, 
                                      (gen_operation(jh, srem, gen_ext(jh, 
-                                         load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(jh, 
-                                         load_reg_from_mem(jh, traits::X0 + rs2), 32, false))
-                                     ), 32, true));
+                                         load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                                         load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
+                                     ), 32, false));
                         }
                     }
                 cc.bind(label_merge);
@@ -3279,7 +3267,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto label_merge = cc.newLabel();
@@ -3348,7 +3336,7 @@ private:
                      ), 32, false));
         }
         else{
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         auto returnValue = CONT;
         
@@ -3476,7 +3464,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rs1!=0){
@@ -3600,7 +3588,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -3646,7 +3634,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0){
             cc.mov(get_ptr_for(jh, traits::X0+ rd),
@@ -3695,7 +3683,7 @@ private:
                      ), 32, true));
         }
         else{
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         auto returnValue = CONT;
         
@@ -3732,7 +3720,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        gen_raise(jh, 0, 2);
+        gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -4199,7 +4187,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rs1!=0){
@@ -4246,7 +4234,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto offs = gen_ext(jh, 
@@ -4295,7 +4283,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -4421,7 +4409,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0){
@@ -4468,7 +4456,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto new_pc = load_reg_from_mem(jh, traits::X0 + rs1);
@@ -4552,7 +4540,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)){
-            gen_raise(jh, 0, 2);
+            gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto offs = gen_ext(jh, 
@@ -4595,7 +4583,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        gen_raise(jh, 0, 2);
+        gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -4616,7 +4604,8 @@ private:
         gen_instr_epilogue(jh);
         this->gen_sync(jh, POST_SYNC, instr_descr.size());
         return BRANCH;
-    }    
+    }
+     
     //decoding functionality
 
     void populate_decoding_tree(decoding_tree_node* root){

From d4ec131fa719e837e1b2b95d2ef23890cba0be12 Mon Sep 17 00:00:00 2001
From: stas <stas@minres.com>
Date: Thu, 4 Jul 2024 10:46:24 +0200
Subject: [PATCH 005/100] change COUNT_LIMIT to ICOUNT_LIMIT

---
 gen_input/templates/interp/CORENAME.cpp.gtl | 2 +-
 src/vm/interp/vm_tgc5c.cpp                  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 373eb55..da349ba 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -269,7 +269,7 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
 }
 
 inline bool is_count_limit_enabled(finish_cond_e cond){
-    return (cond & finish_cond_e::COUNT_LIMIT) == finish_cond_e::COUNT_LIMIT;
+    return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
 }
 
 inline bool is_jump_to_self_enabled(finish_cond_e cond){
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 9b6fcb9..0411fd2 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -349,7 +349,7 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
 }
 
 inline bool is_count_limit_enabled(finish_cond_e cond){
-    return (cond & finish_cond_e::COUNT_LIMIT) == finish_cond_e::COUNT_LIMIT;
+    return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
 }
 
 inline bool is_jump_to_self_enabled(finish_cond_e cond){
@@ -2718,4 +2718,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
\ No newline at end of file
+// clang-format on

From 346b177a87b8bfa9f3e895e63910f9c7cf7a1561 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 21 Jun 2024 11:51:15 +0200
Subject: [PATCH 006/100] extends finishing conditions

---
 gen_input/templates/interp/CORENAME.cpp.gtl | 15 ++++++++++++---
 src/vm/interp/vm_tgc5c.cpp                  | 19 ++++++++++++++-----
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index da349ba..99e60ac 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -117,6 +117,8 @@ protected:
         this->core.wait_until(type);
     }
 
+    uint64_t fetch_count{0};
+
     using yield_t = boost::coroutines2::coroutine<void>::push_type;
     using coro_t = boost::coroutines2::coroutine<void>::pull_type;
     std::vector<coro_t> spawn_blocks;
@@ -219,6 +221,7 @@ private:
             }); 
         }
     }
+
     typename arch::traits<ARCH>::opcode_e  decode_instr(decoding_tree_node* node, code_word_t word){
         if(!node->children.size()){
             if(node->instrs.size() == 1) return node->instrs[0].op;
@@ -268,16 +271,20 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
     populate_decoding_tree(root);
 }
 
-inline bool is_count_limit_enabled(finish_cond_e cond){
+inline bool is_icount_limit_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
 }
 
+inline bool is_fcount_limit_enabled(finish_cond_e cond){
+    return (cond & finish_cond_e::FCOUNT_LIMIT) == finish_cond_e::FCOUNT_LIMIT;
+}
+
 inline bool is_jump_to_self_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::JUMP_TO_SELF) == finish_cond_e::JUMP_TO_SELF;
 }
 
 template <typename ARCH>
-typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit){
+typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t count_limit){
     auto pc=start;
     auto* PC = reinterpret_cast<uint${addrDataWidth}_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC]);
     auto* NEXT_PC = reinterpret_cast<uint${addrDataWidth}_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::NEXT_PC]);
@@ -290,7 +297,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
     auto *const data = reinterpret_cast<uint8_t*>(&instr);
 
     while(!this->core.should_stop() &&
-            !(is_count_limit_enabled(cond) && icount >= icount_limit)){
+            !(is_icount_limit_enabled(cond) && icount >= count_limit) &&
+            !(is_fcount_limit_enabled(cond) && fetch_count >= count_limit)){
+        fetch_count++;
         if(fetch_ins(pc, data)!=iss::Ok){
             this->do_sync(POST_SYNC, std::numeric_limits<unsigned>::max());
             pc.val = super::core.enter_trap(std::numeric_limits<uint64_t>::max(), pc.val, 0);
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 0411fd2..a8d1e8f 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2021 MINRES Technologies GmbH
+ * Copyright (C) 20217-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -113,6 +113,8 @@ protected:
         this->core.wait_until(type);
     }
 
+    uint64_t fetch_count{0};
+
     using yield_t = boost::coroutines2::coroutine<void>::push_type;
     using coro_t = boost::coroutines2::coroutine<void>::pull_type;
     std::vector<coro_t> spawn_blocks;
@@ -299,6 +301,7 @@ private:
             }); 
         }
     }
+
     typename arch::traits<ARCH>::opcode_e  decode_instr(decoding_tree_node* node, code_word_t word){
         if(!node->children.size()){
             if(node->instrs.size() == 1) return node->instrs[0].op;
@@ -348,16 +351,20 @@ vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
     populate_decoding_tree(root);
 }
 
-inline bool is_count_limit_enabled(finish_cond_e cond){
+inline bool is_icount_limit_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
 }
 
+inline bool is_fcount_limit_enabled(finish_cond_e cond){
+    return (cond & finish_cond_e::FCOUNT_LIMIT) == finish_cond_e::FCOUNT_LIMIT;
+}
+
 inline bool is_jump_to_self_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::JUMP_TO_SELF) == finish_cond_e::JUMP_TO_SELF;
 }
 
 template <typename ARCH>
-typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit){
+typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t count_limit){
     auto pc=start;
     auto* PC = reinterpret_cast<uint32_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC]);
     auto* NEXT_PC = reinterpret_cast<uint32_t*>(this->regs_base_ptr+arch::traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::NEXT_PC]);
@@ -370,7 +377,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
     auto *const data = reinterpret_cast<uint8_t*>(&instr);
 
     while(!this->core.should_stop() &&
-            !(is_count_limit_enabled(cond) && icount >= icount_limit)){
+            !(is_icount_limit_enabled(cond) && icount >= count_limit) &&
+            !(is_fcount_limit_enabled(cond) && fetch_count >= count_limit)){
+        fetch_count++;
         if(fetch_ins(pc, data)!=iss::Ok){
             this->do_sync(POST_SYNC, std::numeric_limits<unsigned>::max());
             pc.val = super::core.enter_trap(std::numeric_limits<uint64_t>::max(), pc.val, 0);
@@ -2718,4 +2727,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
+// clang-format on
\ No newline at end of file

From fd303c83436fabe397af73686abd0d1158de27a3 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 5 Jul 2024 07:51:37 +0200
Subject: [PATCH 007/100] fixes asmjit deprecation warning

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |   4 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 178 ++++++++++----------
 2 files changed, 91 insertions(+), 91 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index e030e99..17e5852 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -147,7 +147,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -318,7 +318,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     cc.mov(instr, 0); // FIXME:this is not correct
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
-    cc.invoke(&call_enter_trap, &enter_trap, FuncSignatureT<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
+    cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index d99a50a..c6acf66 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -322,7 +322,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -368,7 +368,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -414,7 +414,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -469,7 +469,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -537,7 +537,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -595,7 +595,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -653,7 +653,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -713,7 +713,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -773,7 +773,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -831,7 +831,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -889,7 +889,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -942,7 +942,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -995,7 +995,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1048,7 +1048,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1100,7 +1100,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1152,7 +1152,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1200,7 +1200,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1248,7 +1248,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1296,7 +1296,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1345,7 +1345,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1407,7 +1407,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1468,7 +1468,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1516,7 +1516,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1564,7 +1564,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1612,7 +1612,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1660,7 +1660,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1708,7 +1708,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1758,7 +1758,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1807,7 +1807,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1856,7 +1856,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1905,7 +1905,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -1968,7 +1968,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2029,7 +2029,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2077,7 +2077,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2126,7 +2126,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2177,7 +2177,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2225,7 +2225,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2275,7 +2275,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2310,7 +2310,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2345,7 +2345,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2380,7 +2380,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2415,7 +2415,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2454,7 +2454,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2507,7 +2507,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2560,7 +2560,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2613,7 +2613,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2662,7 +2662,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2714,7 +2714,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2766,7 +2766,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2805,7 +2805,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2857,7 +2857,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2910,7 +2910,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -2962,7 +2962,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3014,7 +3014,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3098,7 +3098,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3162,7 +3162,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3250,7 +3250,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3313,7 +3313,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3360,7 +3360,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3405,7 +3405,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3447,7 +3447,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3493,7 +3493,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3529,7 +3529,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3571,7 +3571,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3617,7 +3617,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3660,7 +3660,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3704,7 +3704,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3742,7 +3742,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3782,7 +3782,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3835,7 +3835,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3876,7 +3876,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3917,7 +3917,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3957,7 +3957,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -3997,7 +3997,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4036,7 +4036,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4076,7 +4076,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4123,7 +4123,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4170,7 +4170,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4217,7 +4217,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4266,7 +4266,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4311,7 +4311,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4354,7 +4354,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4392,7 +4392,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4439,7 +4439,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4485,7 +4485,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4523,7 +4523,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4567,7 +4567,7 @@ private:
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
-            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignatureT<void, void *, uint64_t, char *>());
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
             call_print_disass->setArg(0, jh.arch_if_ptr);
             call_print_disass->setArg(1, pc.val);
             call_print_disass->setArg(2, mnemonic_ptr);
@@ -4739,7 +4739,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     cc.mov(instr, 0); // FIXME:this is not correct
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
-    cc.invoke(&call_enter_trap, &enter_trap, FuncSignatureT<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
+    cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
@@ -4802,4 +4802,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
\ No newline at end of file
+// clang-format on

From 24449f1c0f113e3692f9845e80dedaaf95e43161 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 5 Jul 2024 12:18:36 +0200
Subject: [PATCH 008/100] fixes some elf load issue

---
 src/iss/arch/riscv_hart_m_p.h    | 3 ++-
 src/iss/arch/riscv_hart_msu_vp.h | 3 ++-
 src/iss/arch/riscv_hart_mu_p.h   | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index dfbef36..ca6e73e 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -605,7 +605,8 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
             for(const auto pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
-                if(fsize > 0) {
+                const auto type = pseg->get_type();
+                if(type==1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 1a350b8..c9f4318 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -589,7 +589,8 @@ template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load
             for(const auto pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
-                if(fsize > 0) {
+                const auto type = pseg->get_type();
+                if(type==1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 5928d4e..cba22b6 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -676,7 +676,8 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
             for(const auto pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
-                if(fsize > 0) {
+                const auto type = pseg->get_type();
+                if(type==1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)

From fb4012fbd180d167447370b568750fcdab61bfd1 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Tue, 9 Jul 2024 13:30:04 +0200
Subject: [PATCH 009/100] moves likely annotation

---
 src/iss/arch/riscv_hart_common.h | 8 ++++++++
 src/iss/arch/riscv_hart_m_p.h    | 8 --------
 src/iss/arch/riscv_hart_msu_vp.h | 8 --------
 src/iss/arch/riscv_hart_mu_p.h   | 8 --------
 4 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/src/iss/arch/riscv_hart_common.h b/src/iss/arch/riscv_hart_common.h
index 829fbb1..f3b1596 100644
--- a/src/iss/arch/riscv_hart_common.h
+++ b/src/iss/arch/riscv_hart_common.h
@@ -44,6 +44,14 @@
 #include <unordered_map>
 #include <util/logging.h>
 
+#if defined(__GNUC__)
+#define likely(x) ::__builtin_expect(!!(x), 1)
+#define unlikely(x) ::__builtin_expect(!!(x), 0)
+#else
+#define likely(x) x
+#define unlikely(x) x
+#endif
+
 namespace iss {
 namespace arch {
 
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index ca6e73e..b032c46 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -58,14 +58,6 @@
 
 #include <iss/semihosting/semihosting.h>
 
-#if defined(__GNUC__)
-#define likely(x) __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-#else
-#define likely(x) x
-#define unlikely(x) x
-#endif
-
 namespace iss {
 namespace arch {
 
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index c9f4318..12da37e 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -57,14 +57,6 @@
 
 #include <iss/semihosting/semihosting.h>
 
-#if defined(__GNUC__)
-#define likely(x) __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-#else
-#define likely(x) x
-#define unlikely(x) x
-#endif
-
 namespace iss {
 namespace arch {
 
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index cba22b6..e6a10a9 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -57,14 +57,6 @@
 
 #include <iss/semihosting/semihosting.h>
 
-#if defined(__GNUC__)
-#define likely(x) __builtin_expect(!!(x), 1)
-#define unlikely(x) __builtin_expect(!!(x), 0)
-#else
-#define likely(x) x
-#define unlikely(x) x
-#endif
-
 namespace iss {
 namespace arch {
 

From 63da7f8d57fab339530e2ac4c808ff71ff3c4941 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Tue, 9 Jul 2024 13:57:11 +0200
Subject: [PATCH 010/100] applies clang-format

---
 src/iss/arch/riscv_hart_m_p.h    | 2 +-
 src/iss/arch/riscv_hart_msu_vp.h | 2 +-
 src/iss/arch/riscv_hart_mu_p.h   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index b032c46..d257d9c 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -598,7 +598,7 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
-                if(type==1 && fsize > 0) {
+                if(type == 1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 12da37e..fd1b844 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -582,7 +582,7 @@ template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
-                if(type==1 && fsize > 0) {
+                if(type == 1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index e6a10a9..345ea27 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -669,7 +669,7 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
-                if(type==1 && fsize > 0) {
+                if(type == 1 && fsize > 0) {
                     auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
                                            pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
                     if(res != iss::Ok)

From 4cfb15c7cd288a138c8c8dd409b15c9326c8c8b7 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 10 Jul 2024 12:51:31 +0200
Subject: [PATCH 011/100] Asmjit and interp working

---
 gen_input/templates/interp/CORENAME.cpp.gtl |   2 +-
 src/iss/arch/tgc5c.h                        |   2 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 299 ++++++++++----------
 src/vm/interp/vm_tgc5c.cpp                  |  52 ++--
 4 files changed, 177 insertions(+), 178 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 99e60ac..567737d 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 20217-2024 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/src/iss/arch/tgc5c.h b/src/iss/arch/tgc5c.h
index 7d51456..606256a 100644
--- a/src/iss/arch/tgc5c.h
+++ b/src/iss/arch/tgc5c.h
@@ -53,7 +53,7 @@ template <> struct traits<tgc5c> {
     static constexpr std::array<const char*, 36> reg_aliases{
         {"zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", "pc", "next_pc", "priv", "dpc"}};
 
-    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
+    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, FLEN=0ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
 
     constexpr static unsigned FP_REGS_SIZE = 0;
 
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index c6acf66..e30c907 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -344,7 +344,7 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     (uint32_t)((int32_t)imm));
+                      (uint32_t)((int32_t)imm));
             }
         }
         auto returnValue = CONT;
@@ -390,7 +390,7 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     (uint32_t)(PC+(int32_t)imm));
+                      (uint32_t)(PC+(int32_t)imm));
             }
         }
         auto returnValue = CONT;
@@ -440,7 +440,7 @@ private:
             else{
                 if(rd!=0){
                     cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                         (uint32_t)(PC+4));
+                          (uint32_t)(PC+4));
                 }
                 auto PC_val_v = (uint32_t)(PC+(int32_t)sext<21>(imm));
                 cc.mov(jh.next_pc, PC_val_v);
@@ -507,7 +507,7 @@ private:
                 {
                     if(rd!=0){
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             (uint32_t)(PC+4));
+                              (uint32_t)(PC+4));
                     }
                     auto PC_val_v = new_pc;
                     cc.mov(jh.next_pc, PC_val_v);
@@ -916,8 +916,8 @@ private:
                 gen_read_mem(jh, traits::MEM, load_address, 1), 8, false);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, true));
+                      gen_ext(jh, 
+                          res, 32, true));
             }
         }
         auto returnValue = CONT;
@@ -969,8 +969,8 @@ private:
                 gen_read_mem(jh, traits::MEM, load_address, 2), 16, false);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, true));
+                      gen_ext(jh, 
+                          res, 32, true));
             }
         }
         auto returnValue = CONT;
@@ -1022,8 +1022,8 @@ private:
                 gen_read_mem(jh, traits::MEM, load_address, 4), 32, false);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, true));
+                      gen_ext(jh, 
+                          res, 32, true));
             }
         }
         auto returnValue = CONT;
@@ -1074,8 +1074,8 @@ private:
             auto res = gen_read_mem(jh, traits::MEM, load_address, 1);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, false));
+                      gen_ext(jh, 
+                          res, 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1126,8 +1126,8 @@ private:
             auto res = gen_read_mem(jh, traits::MEM, load_address, 2);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, false));
+                      gen_ext(jh, 
+                          res, 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1318,9 +1318,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -1379,8 +1379,8 @@ private:
                 cc.mov(tmp_reg,1);
                 cc.bind(label_merge);
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, tmp_reg
-                     , 32, false)
+                      gen_ext(jh, tmp_reg
+                      , 32, false)
                 );
                 }
             }
@@ -1440,8 +1440,8 @@ private:
                 cc.mov(tmp_reg,1);
                 cc.bind(label_merge);
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, tmp_reg
-                     , 32, false)
+                      gen_ext(jh, tmp_reg
+                      , 32, false)
                 );
                 }
             }
@@ -1490,8 +1490,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
-                     );
+                      gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -1538,8 +1538,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
-                     );
+                      gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -1586,8 +1586,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
-                     );
+                      gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -1634,8 +1634,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
-                     );
+                      gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
+                      );
             }
         }
         auto returnValue = CONT;
@@ -1682,8 +1682,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
-                     );
+                      gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
+                      );
             }
         }
         auto returnValue = CONT;
@@ -1730,10 +1730,10 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, sar, gen_ext(jh, 
-                             load_reg_from_mem(jh, traits::X0 + rs1), 32, true), shamt)
-                         ), 32, false));
+                      gen_ext(jh, 
+                          (gen_operation(jh, sar, gen_ext(jh, 
+                              load_reg_from_mem(jh, traits::X0 + rs1), 32, true), shamt)
+                          ), 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1780,9 +1780,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                         ), 32, false));
+                      gen_ext(jh, 
+                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          ), 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1829,9 +1829,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -1878,9 +1878,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
-                     ))
-                     , 32, false));
+                      gen_ext(jh, gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      ))
+                      , 32, false));
             }
         }
         auto returnValue = CONT;
@@ -1940,8 +1940,8 @@ private:
                 cc.mov(tmp_reg,1);
                 cc.bind(label_merge);
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, tmp_reg
-                     , 32, false)
+                      gen_ext(jh, tmp_reg
+                      , 32, false)
                 );
                 }
             }
@@ -2001,8 +2001,8 @@ private:
                 cc.mov(tmp_reg,1);
                 cc.bind(label_merge);
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, tmp_reg
-                     , 32, false)
+                      gen_ext(jh, tmp_reg
+                      , 32, false)
                 );
                 }
             }
@@ -2051,8 +2051,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                     );
+                      gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -2099,9 +2099,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
-                     ))
-                     , 32, false));
+                      gen_ext(jh, gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      ))
+                      , 32, false));
             }
         }
         auto returnValue = CONT;
@@ -2148,11 +2148,11 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_ext(jh, gen_operation(jh, sar, gen_ext(jh, 
-                             load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
-                         ))
-                         , 32, true)), 32, true));
+                      gen_ext(jh, 
+                          (gen_ext(jh, gen_operation(jh, sar, gen_ext(jh, 
+                              load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                          ))
+                          , 32, true)), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -2199,8 +2199,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                     );
+                      gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -2247,8 +2247,8 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                     );
+                      gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      );
             }
         }
         auto returnValue = CONT;
@@ -2479,7 +2479,7 @@ private:
                 auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
                 gen_write_mem(jh, traits::CSR, csr, xrs1, 4);
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
             else{
                 gen_write_mem(jh, traits::CSR, csr, xrs1, 4);
@@ -2535,7 +2535,7 @@ private:
             }
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
         }
         auto returnValue = CONT;
@@ -2588,7 +2588,7 @@ private:
             }
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
         }
         auto returnValue = CONT;
@@ -2637,7 +2637,7 @@ private:
             gen_write_mem(jh, traits::CSR, csr, (uint32_t)zimm, 4);
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
         }
         auto returnValue = CONT;
@@ -2689,7 +2689,7 @@ private:
             }
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
         }
         auto returnValue = CONT;
@@ -2741,7 +2741,7 @@ private:
             }
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     xrd);
+                      xrd);
             }
         }
         auto returnValue = CONT;
@@ -2825,14 +2825,14 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, imul, gen_ext(jh, 
+            auto res = gen_operation(jh, smul, gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         res, 32, true));
+                      gen_ext(jh, 
+                          res, 32, true));
             }
         }
         auto returnValue = CONT;
@@ -2877,15 +2877,15 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, imul, gen_ext(jh, 
+            auto res = gen_operation(jh, smul, gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -2930,14 +2930,14 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, imul, gen_ext(jh, 
+            auto res = gen_operation(jh, sumul, gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true), load_reg_from_mem(jh, traits::X0 + rs2))
             ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -2982,14 +2982,13 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, mul,
-                load_reg_from_mem(jh, traits::X0 + rs1),
-                load_reg_from_mem(jh, traits::X0 + rs2));
+            auto res = gen_operation(jh, umul, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            ;
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, shr, res, static_cast<uint32_t>(traits::XLEN))
-                         ), 32, false));
+                      gen_ext(jh, 
+                          (gen_operation(jh, shr, res, static_cast<uint32_t>(traits::XLEN))
+                          ), 32, false));
             }
         }
         auto returnValue = CONT;
@@ -3055,15 +3054,15 @@ private:
                     cc.je(label_else);
                     {
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             MMIN);
+                              MMIN);
                     }
                     cc.jmp(label_merge);
                     cc.bind(label_else);
                         {
                             cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                                 gen_ext(jh, 
-                                     (gen_operation(jh, idiv, dividend, divisor)
-                                     ), 32, true));
+                                  gen_ext(jh, 
+                                      (gen_operation(jh, sdiv, dividend, divisor)
+                                      ), 32, true));
                         }
                     cc.bind(label_merge);
                 }
@@ -3071,7 +3070,7 @@ private:
                 cc.bind(label_else);
                     {
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             (uint32_t)- 1);
+                              (uint32_t)- 1);
                     }
                 cc.bind(label_merge);
             }
@@ -3126,8 +3125,8 @@ private:
             {
                 if(rd!=0){
                     cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                         gen_operation(jh, div, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                         );
+                          gen_operation(jh, udiv, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          );
                 }
             }
             cc.jmp(label_merge);
@@ -3135,7 +3134,7 @@ private:
                 {
                     if(rd!=0){
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             (uint32_t)- 1);
+                              (uint32_t)- 1);
                     }
                 }
             cc.bind(label_merge);
@@ -3200,7 +3199,7 @@ private:
                 {
                     if(rd!=0){
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             gen_ext(jh, 0, 32, false)
+                              gen_ext(jh, 0, 32, false)
                         );
                     }
                 }
@@ -3209,11 +3208,11 @@ private:
                     {
                         if(rd!=0){
                             cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                                 gen_ext(jh, 
-                                     (gen_operation(jh, srem, gen_ext(jh, 
-                                         load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
-                                         load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
-                                     ), 32, false));
+                                  gen_ext(jh, 
+                                      (gen_operation(jh, srem, gen_ext(jh, 
+                                          load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                                          load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
+                                      ), 32, false));
                         }
                     }
                 cc.bind(label_merge);
@@ -3223,7 +3222,7 @@ private:
                 {
                     if(rd!=0){
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             load_reg_from_mem(jh, traits::X0 + rs1));
+                              load_reg_from_mem(jh, traits::X0 + rs1));
                     }
                 }
             cc.bind(label_merge);
@@ -3278,8 +3277,8 @@ private:
             {
                 if(rd!=0){
                     cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                         gen_operation(jh, urem, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
-                         );
+                          gen_operation(jh, urem, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          );
                 }
             }
             cc.jmp(label_merge);
@@ -3287,7 +3286,7 @@ private:
                 {
                     if(rd!=0){
                         cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                             load_reg_from_mem(jh, traits::X0 + rs1));
+                              load_reg_from_mem(jh, traits::X0 + rs1));
                     }
                 }
             cc.bind(label_merge);
@@ -3331,9 +3330,9 @@ private:
         /*generate behavior*/
         if(imm){
             cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-                 gen_ext(jh, 
-                     (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), imm)
-                     ), 32, false));
+                  gen_ext(jh, 
+                      (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), imm)
+                      ), 32, false));
         }
         else{
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3380,9 +3379,9 @@ private:
             (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
             ), 32, false);
         cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-             gen_ext(jh, 
-                 gen_ext(jh, 
-                     gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
+              gen_ext(jh, 
+                  gen_ext(jh, 
+                      gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -3469,9 +3468,9 @@ private:
         else{
             if(rs1!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rs1),
-                     gen_ext(jh, 
-                         (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int8_t)sext<6>(imm))
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int8_t)sext<6>(imm))
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -3546,7 +3545,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ 1),
-             (uint32_t)(PC+2));
+              (uint32_t)(PC+2));
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         cc.mov(jh.next_pc, PC_val_v);
         cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
@@ -3593,7 +3592,7 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     (uint32_t)((int8_t)sext<6>(imm)));
+                      (uint32_t)((int8_t)sext<6>(imm)));
             }
         }
         auto returnValue = CONT;
@@ -3638,7 +3637,7 @@ private:
         }
         if(rd!=0){
             cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                 (uint32_t)((int32_t)sext<18>(imm)));
+                  (uint32_t)((int32_t)sext<18>(imm)));
         }
         auto returnValue = CONT;
         
@@ -3678,9 +3677,9 @@ private:
         /*generate behavior*/
         if(nzimm){
             cc.mov(get_ptr_for(jh, traits::X0+ 2),
-                 gen_ext(jh, 
-                     (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), (int16_t)sext<10>(nzimm))
-                     ), 32, true));
+                  gen_ext(jh, 
+                      (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), (int16_t)sext<10>(nzimm))
+                      ), 32, true));
         }
         else{
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3759,8 +3758,8 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
-             gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1+8), shamt)
-             );
+              gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1+8), shamt)
+              );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -3800,18 +3799,18 @@ private:
         /*generate behavior*/
         if(shamt){
             cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
-                 gen_ext(jh, 
-                     (gen_operation(jh, sar, (gen_ext(jh, 
-                         load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), shamt)
-                     ), 32, true));
+                  gen_ext(jh, 
+                      (gen_operation(jh, sar, (gen_ext(jh, 
+                          load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), shamt)
+                      ), 32, true));
         }
         else{
             if(static_cast<uint32_t>(traits::XLEN)==128){
                 cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
-                     gen_ext(jh, 
-                         (gen_operation(jh, sar, (gen_ext(jh, 
-                             load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), 64)
-                         ), 32, true));
+                      gen_ext(jh, 
+                          (gen_operation(jh, sar, (gen_ext(jh, 
+                              load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), 64)
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;
@@ -3852,9 +3851,9 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
-             gen_ext(jh, 
-                 (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1+8), (int8_t)sext<6>(imm))
-                 ), 32, true));
+              gen_ext(jh, 
+                  (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1+8), (int8_t)sext<6>(imm))
+                  ), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -3893,9 +3892,9 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-             gen_ext(jh, 
-                 (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
-                 ), 32, true));
+              gen_ext(jh, 
+                  (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+                  ), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -3934,8 +3933,8 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-             gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
-             );
+              gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -3974,8 +3973,8 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-             gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
-             );
+              gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -4014,8 +4013,8 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
-             gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
-             );
+              gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
@@ -4192,8 +4191,8 @@ private:
         else{
             if(rs1!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rs1),
-                     gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), nzuimm)
-                     );
+                      gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), nzuimm)
+                      );
             }
         }
         auto returnValue = CONT;
@@ -4241,9 +4240,9 @@ private:
                 (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
                 ), 32, false);
             cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                 gen_ext(jh, 
-                     gen_ext(jh, 
-                         gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
+                  gen_ext(jh, 
+                      gen_ext(jh, 
+                          gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
         }
         auto returnValue = CONT;
         
@@ -4288,7 +4287,7 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     load_reg_from_mem(jh, traits::X0 + rs2));
+                      load_reg_from_mem(jh, traits::X0 + rs2));
             }
         }
         auto returnValue = CONT;
@@ -4414,9 +4413,9 @@ private:
         else{
             if(rd!=0){
                 cc.mov(get_ptr_for(jh, traits::X0+ rd),
-                     gen_ext(jh, 
-                         (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rd), load_reg_from_mem(jh, traits::X0 + rs2))
-                         ), 32, false));
+                      gen_ext(jh, 
+                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rd), load_reg_from_mem(jh, traits::X0 + rs2))
+                          ), 32, false));
             }
         }
         auto returnValue = CONT;
@@ -4461,7 +4460,7 @@ private:
         else{
             auto new_pc = load_reg_from_mem(jh, traits::X0 + rs1);
             cc.mov(get_ptr_for(jh, traits::X0+ 1),
-                 (uint32_t)(PC+2));
+                  (uint32_t)(PC+2));
             auto PC_val_v = gen_operation(jh, band, new_pc, ~ 1)
             ;
             cc.mov(jh.next_pc, PC_val_v);
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index a8d1e8f..70b1195 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -732,9 +732,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int8_t res_27 = super::template read_mem<int8_t>(traits::MEM, load_address);
+                                        int8_t res_40 = super::template read_mem<int8_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int8_t res = (int8_t)res_27;
+                                        int8_t res = (int8_t)res_40;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -763,9 +763,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int16_t res_28 = super::template read_mem<int16_t>(traits::MEM, load_address);
+                                        int16_t res_41 = super::template read_mem<int16_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int16_t res = (int16_t)res_28;
+                                        int16_t res = (int16_t)res_41;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -794,9 +794,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int32_t res_29 = super::template read_mem<int32_t>(traits::MEM, load_address);
+                                        int32_t res_42 = super::template read_mem<int32_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int32_t res = (int32_t)res_29;
+                                        int32_t res = (int32_t)res_42;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -825,9 +825,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        uint8_t res_30 = super::template read_mem<uint8_t>(traits::MEM, load_address);
+                                        uint8_t res_43 = super::template read_mem<uint8_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint8_t res = res_30;
+                                        uint8_t res = res_43;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -856,9 +856,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        uint16_t res_31 = super::template read_mem<uint16_t>(traits::MEM, load_address);
+                                        uint16_t res_44 = super::template read_mem<uint16_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint16_t res = res_31;
+                                        uint16_t res = res_44;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -1556,9 +1556,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     else {
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rd != 0) {
-                                            uint32_t res_32 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                            uint32_t res_45 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                            uint32_t xrd = res_32;
+                                            uint32_t xrd = res_45;
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrs1);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
                                             *(X+rd) = xrd;
@@ -1591,9 +1591,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_33 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_46 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_33;
+                                        uint32_t xrd = res_46;
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rs1 != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd | xrs1);
@@ -1626,9 +1626,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_34 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_47 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_34;
+                                        uint32_t xrd = res_47;
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rs1 != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd & ~ xrs1);
@@ -1661,9 +1661,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_35 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_48 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_35;
+                                        uint32_t xrd = res_48;
                                         super::template write_mem<uint32_t>(traits::CSR, csr, (uint32_t)zimm);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
                                         if(rd != 0) {
@@ -1693,9 +1693,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_36 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_49 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_36;
+                                        uint32_t xrd = res_49;
                                         if(zimm != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd | (uint32_t)zimm);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
@@ -1727,9 +1727,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_37 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_50 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_37;
+                                        uint32_t xrd = res_50;
                                         if(zimm != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd & ~ ((uint32_t)zimm));
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
@@ -2064,9 +2064,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                         uint32_t offs = (uint32_t)((uint64_t)(*(X+rs1 + 8) ) + (uint64_t)(uimm ));
-                        int32_t res_38 = super::template read_mem<int32_t>(traits::MEM, offs);
+                        int32_t res_51 = super::template read_mem<int32_t>(traits::MEM, offs);
                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                        *(X+rd + 8) = (uint32_t)(int32_t)res_38;
+                        *(X+rd + 8) = (uint32_t)(int32_t)res_51;
                     }
                     break;
                 }// @suppress("No break at end of case")
@@ -2486,9 +2486,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                         }
                         else {
                             uint32_t offs = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)(uimm ));
-                            int32_t res_39 = super::template read_mem<int32_t>(traits::MEM, offs);
+                            int32_t res_52 = super::template read_mem<int32_t>(traits::MEM, offs);
                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                            *(X+rd) = (uint32_t)(int32_t)res_39;
+                            *(X+rd) = (uint32_t)(int32_t)res_52;
                         }
                     }
                     break;

From 5b17599aa2a7ec838187c340aad300ad86ca2c1a Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 3 Jul 2024 12:45:13 +0200
Subject: [PATCH 012/100] allows usage of std::variants

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |  51 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 641 ++++++++++----------
 2 files changed, 351 insertions(+), 341 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 17e5852..6a7a40e 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -79,10 +79,15 @@ public:
     }
 
 protected:
+    using super::mov;
+    using super::cmp;
     using super::get_ptr_for;
-using super::get_reg;
+    using super::get_reg;
+    using super::get_reg_Gp;
     using super::get_reg_for;
+    using super::get_reg_for_Gp;
     using super::load_reg_from_mem;
+    using super::load_reg_from_mem_Gp;
     using super::write_reg_to_mem;
     using super::gen_ext;
     using super::gen_read_mem;
@@ -156,9 +161,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("${instr.name}_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, ${idx});
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+${instr.length/8};
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -277,9 +282,9 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     cc.comment("//gen_instr_prologue");
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
-    cc.mov(get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
+    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    mov(cc, get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
 
 }
 template <typename ARCH>
@@ -287,16 +292,16 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_epilogue");
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
-    cc.cmp(current_trap_state, 0);
+    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
 
-    jh.pc = load_reg_from_mem(jh, traits::PC);
-    jh.next_pc = load_reg_from_mem(jh, traits::NEXT_PC);
+    jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
+    jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -308,14 +313,14 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     this->write_back(jh);
     this->gen_sync(jh, POST_SYNC, -1);
 
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    x86::Gp current_trap_state = get_reg_for_Gp(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
 
-    x86::Gp current_pc = get_reg_for(jh, traits::PC);
-    cc.mov(current_pc, get_ptr_for(jh, traits::PC));
+    x86::Gp current_pc = get_reg_for_Gp(jh, traits::PC);
+    mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
     x86::Gp instr = cc.newInt32("instr");
-    cc.mov(instr, 0); // FIXME:this is not correct
+    mov(cc, instr, 0); // FIXME:this is not correct, should be instrId of trapping instr
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
     cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
@@ -324,11 +329,11 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(2, current_pc);
     call_enter_trap->setArg(3, instr);
 
-    x86::Gp current_next_pc = get_reg_for(jh, traits::NEXT_PC);
-    cc.mov(current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
-    cc.mov(jh.next_pc, current_next_pc);
+    x86_reg_t current_next_pc = get_reg_for(jh, traits::NEXT_PC);
+    mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
+    mov(cc, jh.next_pc, current_next_pc);
 
-    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
+    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
     cc.ret(jh.next_pc);
 }
 template <typename ARCH>
@@ -336,9 +341,9 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto& cc = jh.cc;
     cc.comment("//gen_raise");
     auto tmp1 = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
-    cc.mov(get_ptr_for(jh, traits::TRAP_STATE), tmp1);
-    cc.mov(jh.next_pc, std::numeric_limits<uint32_t>::max());
+    mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
+    mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
+    mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());
 }
 
 } // namespace tgc5c
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index e30c907..4ba664e 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -79,10 +79,15 @@ public:
     }
 
 protected:
+    using super::mov;
+    using super::cmp;
     using super::get_ptr_for;
-using super::get_reg;
+    using super::get_reg;
+    using super::get_reg_Gp;
     using super::get_reg_for;
+    using super::get_reg_for_Gp;
     using super::load_reg_from_mem;
+    using super::load_reg_from_mem_Gp;
     using super::write_reg_to_mem;
     using super::gen_ext;
     using super::gen_read_mem;
@@ -331,9 +336,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LUI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 0);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -343,7 +348,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       (uint32_t)((int32_t)imm));
             }
         }
@@ -377,9 +382,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("AUIPC_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 1);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -389,7 +394,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       (uint32_t)(PC+(int32_t)imm));
             }
         }
@@ -423,9 +428,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("JAL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 2);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -439,12 +444,12 @@ private:
             }
             else{
                 if(rd!=0){
-                    cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                    mov(cc, get_ptr_for(jh, traits::X0+ rd),
                           (uint32_t)(PC+4));
                 }
                 auto PC_val_v = (uint32_t)(PC+(int32_t)sext<21>(imm));
-                cc.mov(jh.next_pc, PC_val_v);
-                cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                mov(cc, jh.next_pc, PC_val_v);
+                mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
             }
         }
         auto returnValue = BRANCH;
@@ -478,9 +483,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("JALR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 3);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -495,7 +500,7 @@ private:
                 ), addr_mask)
                 ), 32, true);
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, urem, new_pc, static_cast<uint32_t>(traits::INSTR_ALIGNMENT))
+            cmp(cc, gen_operation(jh, urem, new_pc, static_cast<uint32_t>(traits::INSTR_ALIGNMENT))
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
@@ -506,12 +511,12 @@ private:
             cc.bind(label_else);
                 {
                     if(rd!=0){
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               (uint32_t)(PC+4));
                     }
                     auto PC_val_v = new_pc;
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             cc.bind(label_merge);
         }
@@ -546,9 +551,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BEQ_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 4);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -558,7 +563,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -567,8 +572,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -604,9 +609,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BNE_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 5);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -616,7 +621,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -625,8 +630,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -662,9 +667,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BLT_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 6);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -674,7 +679,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, lt, gen_ext(jh, 
+            cmp(cc, gen_operation(jh, lt, gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false))
             ,0);
@@ -685,8 +690,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -722,9 +727,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BGE_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 7);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -734,7 +739,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, gte, gen_ext(jh, 
+            cmp(cc, gen_operation(jh, gte, gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(jh, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false))
             ,0);
@@ -745,8 +750,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -782,9 +787,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BLTU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 8);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -794,7 +799,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, ltu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(jh, ltu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -803,8 +808,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -840,9 +845,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BGEU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 9);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -852,7 +857,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, gteu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(jh, gteu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -861,8 +866,8 @@ private:
                 }
                 else{
                     auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
-                    cc.mov(jh.next_pc, PC_val_v);
-                    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, jh.next_pc, PC_val_v);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
             }
             cc.bind(label_merge);
@@ -898,9 +903,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LB_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 10);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -915,7 +920,7 @@ private:
             auto res = gen_ext(jh, 
                 gen_read_mem(jh, traits::MEM, load_address, 1), 8, false);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, true));
             }
@@ -951,9 +956,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LH_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 11);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -968,7 +973,7 @@ private:
             auto res = gen_ext(jh, 
                 gen_read_mem(jh, traits::MEM, load_address, 2), 16, false);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, true));
             }
@@ -1004,9 +1009,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LW_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 12);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1021,7 +1026,7 @@ private:
             auto res = gen_ext(jh, 
                 gen_read_mem(jh, traits::MEM, load_address, 4), 32, false);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, true));
             }
@@ -1057,9 +1062,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LBU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 13);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1073,7 +1078,7 @@ private:
                 ), 32, true);
             auto res = gen_read_mem(jh, traits::MEM, load_address, 1);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, false));
             }
@@ -1109,9 +1114,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LHU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 14);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1125,7 +1130,7 @@ private:
                 ), 32, true);
             auto res = gen_read_mem(jh, traits::MEM, load_address, 2);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, false));
             }
@@ -1161,9 +1166,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SB_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 15);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1209,9 +1214,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SH_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 16);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1257,9 +1262,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SW_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 17);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1305,9 +1310,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ADDI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 18);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1317,7 +1322,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                           ), 32, true));
@@ -1354,9 +1359,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 19);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1370,15 +1375,15 @@ private:
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
                 auto tmp_reg = get_reg_for(jh, 1);
-                cc.cmp(gen_ext(jh, 
+                cmp(cc, gen_ext(jh, 
                     load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (int16_t)sext<12>(imm));
                 cc.jl(label_then);
-                cc.mov(tmp_reg,0);
+                mov(cc, tmp_reg,0);
                 cc.jmp(label_merge);
                 cc.bind(label_then);
-                cc.mov(tmp_reg,1);
+                mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, tmp_reg
                       , 32, false)
                 );
@@ -1416,9 +1421,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTIU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 20);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1432,14 +1437,14 @@ private:
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
                 auto tmp_reg = get_reg_for(jh, 1);
-                cc.cmp(load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)));
+                cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)));
                 cc.jb(label_then);
-                cc.mov(tmp_reg,0);
+                mov(cc, tmp_reg,0);
                 cc.jmp(label_merge);
                 cc.bind(label_then);
-                cc.mov(tmp_reg,1);
+                mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, tmp_reg
                       , 32, false)
                 );
@@ -1477,9 +1482,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("XORI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 21);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1489,7 +1494,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
@@ -1525,9 +1530,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ORI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 22);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1537,7 +1542,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
@@ -1573,9 +1578,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ANDI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 23);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1585,7 +1590,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
@@ -1621,9 +1626,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLLI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 24);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1633,7 +1638,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
                       );
             }
@@ -1669,9 +1674,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRLI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 25);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1681,7 +1686,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
                       );
             }
@@ -1717,9 +1722,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRAI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 26);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1729,7 +1734,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, sar, gen_ext(jh, 
                               load_reg_from_mem(jh, traits::X0 + rs1), 32, true), shamt)
@@ -1767,9 +1772,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ADD_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 27);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1779,7 +1784,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, false));
@@ -1816,9 +1821,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SUB_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 28);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1828,7 +1833,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, true));
@@ -1865,9 +1870,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 29);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1877,7 +1882,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
                       , 32, false));
@@ -1914,9 +1919,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLT_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 30);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1930,16 +1935,16 @@ private:
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
                 auto tmp_reg = get_reg_for(jh, 1);
-                cc.cmp(gen_ext(jh, 
+                cmp(cc, gen_ext(jh, 
                     load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
                     load_reg_from_mem(jh, traits::X0 + rs2), 32, true));
                 cc.jl(label_then);
-                cc.mov(tmp_reg,0);
+                mov(cc, tmp_reg,0);
                 cc.jmp(label_merge);
                 cc.bind(label_then);
-                cc.mov(tmp_reg,1);
+                mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, tmp_reg
                       , 32, false)
                 );
@@ -1977,9 +1982,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 31);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -1993,14 +1998,14 @@ private:
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
                 auto tmp_reg = get_reg_for(jh, 1);
-                cc.cmp(load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2));
+                cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2));
                 cc.jb(label_then);
-                cc.mov(tmp_reg,0);
+                mov(cc, tmp_reg,0);
                 cc.jmp(label_merge);
                 cc.bind(label_then);
-                cc.mov(tmp_reg,1);
+                mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, tmp_reg
                       , 32, false)
                 );
@@ -2038,9 +2043,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("XOR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 32);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2050,7 +2055,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
@@ -2086,9 +2091,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 33);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2098,7 +2103,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
                       , 32, false));
@@ -2135,9 +2140,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRA_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 34);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2147,7 +2152,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_ext(jh, gen_operation(jh, sar, gen_ext(jh, 
                               load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
@@ -2186,9 +2191,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("OR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 35);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2198,7 +2203,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
@@ -2234,9 +2239,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("AND_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 36);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2246,7 +2251,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
@@ -2284,9 +2289,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("FENCE_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 37);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2319,9 +2324,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ECALL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 38);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2354,9 +2359,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("EBREAK_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 39);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2389,9 +2394,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MRET_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 40);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2424,9 +2429,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("WFI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 41);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2463,9 +2468,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRW_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 42);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2478,7 +2483,7 @@ private:
             if(rd!=0){
                 auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
                 gen_write_mem(jh, traits::CSR, csr, xrs1, 4);
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
             else{
@@ -2516,9 +2521,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRS_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 43);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2534,7 +2539,7 @@ private:
                 , 4);
             }
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
         }
@@ -2569,9 +2574,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRC_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 44);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2587,7 +2592,7 @@ private:
                 , 4);
             }
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
         }
@@ -2622,9 +2627,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRWI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 45);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2636,7 +2641,7 @@ private:
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
             gen_write_mem(jh, traits::CSR, csr, (uint32_t)zimm, 4);
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
         }
@@ -2671,9 +2676,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRSI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 46);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2688,7 +2693,7 @@ private:
                 , 4);
             }
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
         }
@@ -2723,9 +2728,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRCI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 47);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2740,7 +2745,7 @@ private:
                 , 4);
             }
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       xrd);
             }
         }
@@ -2775,9 +2780,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("FENCE_I_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 48);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2814,9 +2819,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MUL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 49);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2830,7 +2835,7 @@ private:
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           res, 32, true));
             }
@@ -2866,9 +2871,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULH_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 50);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2882,7 +2887,7 @@ private:
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, true));
@@ -2919,9 +2924,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULHSU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 51);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2934,7 +2939,7 @@ private:
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true), load_reg_from_mem(jh, traits::X0 + rs2))
             ;
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, true));
@@ -2971,9 +2976,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULHU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 52);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -2985,7 +2990,7 @@ private:
             auto res = gen_operation(jh, umul, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ;
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, shr, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, false));
@@ -3022,9 +3027,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DIV_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 53);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3039,27 +3044,27 @@ private:
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true);
             if(rd!=0){
                 auto label_merge = cc.newLabel();
-                cc.cmp(gen_operation(jh, ne, divisor, 0)
+                cmp(cc, gen_operation(jh, ne, divisor, 0)
                 ,0);
                 auto label_else = cc.newLabel();
                 cc.je(label_else);
                 {
                     auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
                     auto label_merge = cc.newLabel();
-                    cc.cmp(gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
+                    cmp(cc, gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
                     , gen_operation(jh, eq, divisor, - 1)
                     )
                     ,0);
                     auto label_else = cc.newLabel();
                     cc.je(label_else);
                     {
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               MMIN);
                     }
                     cc.jmp(label_merge);
                     cc.bind(label_else);
                         {
-                            cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                            mov(cc, get_ptr_for(jh, traits::X0+ rd),
                                   gen_ext(jh, 
                                       (gen_operation(jh, sdiv, dividend, divisor)
                                       ), 32, true));
@@ -3069,7 +3074,7 @@ private:
                 cc.jmp(label_merge);
                 cc.bind(label_else);
                     {
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               (uint32_t)- 1);
                     }
                 cc.bind(label_merge);
@@ -3106,9 +3111,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DIVU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 54);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3118,13 +3123,13 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 if(rd!=0){
-                    cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                    mov(cc, get_ptr_for(jh, traits::X0+ rd),
                           gen_operation(jh, udiv, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           );
                 }
@@ -3133,7 +3138,7 @@ private:
             cc.bind(label_else);
                 {
                     if(rd!=0){
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               (uint32_t)- 1);
                     }
                 }
@@ -3170,9 +3175,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("REM_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 55);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3182,14 +3187,14 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto label_merge = cc.newLabel();
-                cc.cmp(gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
+                cmp(cc, gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
                 , gen_operation(jh, eq, gen_ext(jh, 
                     load_reg_from_mem(jh, traits::X0 + rs2), 32, false), - 1)
                 )
@@ -3198,7 +3203,7 @@ private:
                 cc.je(label_else);
                 {
                     if(rd!=0){
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               gen_ext(jh, 0, 32, false)
                         );
                     }
@@ -3207,7 +3212,7 @@ private:
                 cc.bind(label_else);
                     {
                         if(rd!=0){
-                            cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                            mov(cc, get_ptr_for(jh, traits::X0+ rd),
                                   gen_ext(jh, 
                                       (gen_operation(jh, srem, gen_ext(jh, 
                                           load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
@@ -3221,7 +3226,7 @@ private:
             cc.bind(label_else);
                 {
                     if(rd!=0){
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               load_reg_from_mem(jh, traits::X0 + rs1));
                     }
                 }
@@ -3258,9 +3263,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("REMU_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 56);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+4;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3270,13 +3275,13 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cc.cmp(gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 if(rd!=0){
-                    cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                    mov(cc, get_ptr_for(jh, traits::X0+ rd),
                           gen_operation(jh, urem, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           );
                 }
@@ -3285,7 +3290,7 @@ private:
             cc.bind(label_else);
                 {
                     if(rd!=0){
-                        cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                        mov(cc, get_ptr_for(jh, traits::X0+ rd),
                               load_reg_from_mem(jh, traits::X0 + rs1));
                     }
                 }
@@ -3321,15 +3326,15 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI4SPN_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 57);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         if(imm){
-            cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+            mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
                   gen_ext(jh, 
                       (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), imm)
                       ), 32, false));
@@ -3368,9 +3373,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LW_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 58);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3378,7 +3383,7 @@ private:
         auto offs = gen_ext(jh, 
             (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
             ), 32, false);
-        cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
               gen_ext(jh, 
                   gen_ext(jh, 
                       gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
@@ -3413,9 +3418,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SW_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 59);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3455,9 +3460,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 60);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3467,7 +3472,7 @@ private:
         }
         else{
             if(rs1!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rs1),
+                mov(cc, get_ptr_for(jh, traits::X0+ rs1),
                       gen_ext(jh, 
                           (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int8_t)sext<6>(imm))
                           ), 32, true));
@@ -3501,9 +3506,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__NOP_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 61);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3537,18 +3542,18 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JAL_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 62);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ 1),
+        mov(cc, get_ptr_for(jh, traits::X0+ 1),
               (uint32_t)(PC+2));
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
-        cc.mov(jh.next_pc, PC_val_v);
-        cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+        mov(cc, jh.next_pc, PC_val_v);
+        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
@@ -3579,9 +3584,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 63);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3591,7 +3596,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       (uint32_t)((int8_t)sext<6>(imm)));
             }
         }
@@ -3625,9 +3630,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LUI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 64);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3636,7 +3641,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0){
-            cc.mov(get_ptr_for(jh, traits::X0+ rd),
+            mov(cc, get_ptr_for(jh, traits::X0+ rd),
                   (uint32_t)((int32_t)sext<18>(imm)));
         }
         auto returnValue = CONT;
@@ -3668,15 +3673,15 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI16SP_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 65);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         if(nzimm){
-            cc.mov(get_ptr_for(jh, traits::X0+ 2),
+            mov(cc, get_ptr_for(jh, traits::X0+ 2),
                   gen_ext(jh, 
                       (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), (int16_t)sext<10>(nzimm))
                       ), 32, true));
@@ -3712,9 +3717,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("__reserved_clui_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 66);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -3750,14 +3755,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SRLI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 67);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
               gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1+8), shamt)
               );
         auto returnValue = CONT;
@@ -3790,15 +3795,15 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SRAI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 68);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         if(shamt){
-            cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
+            mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
                   gen_ext(jh, 
                       (gen_operation(jh, sar, (gen_ext(jh, 
                           load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), shamt)
@@ -3806,7 +3811,7 @@ private:
         }
         else{
             if(static_cast<uint32_t>(traits::XLEN)==128){
-                cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
+                mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
                       gen_ext(jh, 
                           (gen_operation(jh, sar, (gen_ext(jh, 
                               load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), 64)
@@ -3843,14 +3848,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ANDI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 69);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rs1+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
               gen_ext(jh, 
                   (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1+8), (int8_t)sext<6>(imm))
                   ), 32, true));
@@ -3884,14 +3889,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SUB_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 70);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
               gen_ext(jh, 
                   (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
                   ), 32, true));
@@ -3925,14 +3930,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__XOR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 71);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
               gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
@@ -3965,14 +3970,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__OR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 72);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
               gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
@@ -4005,14 +4010,14 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__AND_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 73);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        cc.mov(get_ptr_for(jh, traits::X0+ rd+8),
+        mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
               gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
@@ -4044,16 +4049,16 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__J_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 74);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
-        cc.mov(jh.next_pc, PC_val_v);
-        cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+        mov(cc, jh.next_pc, PC_val_v);
+        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
@@ -4084,21 +4089,21 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__BEQZ_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 75);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         auto label_merge = cc.newLabel();
-        cc.cmp(gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
+        cmp(cc, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
         cc.je(label_merge);
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
-            cc.mov(jh.next_pc, PC_val_v);
-            cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, jh.next_pc, PC_val_v);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         }
         cc.bind(label_merge);
         auto returnValue = BRANCH;
@@ -4131,21 +4136,21 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__BNEZ_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 76);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
         auto label_merge = cc.newLabel();
-        cc.cmp(gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
+        cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
         cc.je(label_merge);
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
-            cc.mov(jh.next_pc, PC_val_v);
-            cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, jh.next_pc, PC_val_v);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         }
         cc.bind(label_merge);
         auto returnValue = BRANCH;
@@ -4178,9 +4183,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SLLI_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 77);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4190,7 +4195,7 @@ private:
         }
         else{
             if(rs1!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rs1),
+                mov(cc, get_ptr_for(jh, traits::X0+ rs1),
                       gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), nzuimm)
                       );
             }
@@ -4225,9 +4230,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LWSP_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 78);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4239,7 +4244,7 @@ private:
             auto offs = gen_ext(jh, 
                 (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
                 ), 32, false);
-            cc.mov(get_ptr_for(jh, traits::X0+ rd),
+            mov(cc, get_ptr_for(jh, traits::X0+ rd),
                   gen_ext(jh, 
                       gen_ext(jh, 
                           gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
@@ -4274,9 +4279,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__MV_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 79);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4286,7 +4291,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       load_reg_from_mem(jh, traits::X0 + rs2));
             }
         }
@@ -4319,9 +4324,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 80);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4329,8 +4334,8 @@ private:
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){
             auto PC_val_v = gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), ~ 1)
             ;
-            cc.mov(jh.next_pc, PC_val_v);
-            cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, jh.next_pc, PC_val_v);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         }
         else{
             gen_raise(jh, 0, 2);
@@ -4362,9 +4367,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("__reserved_cmv_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 81);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4400,9 +4405,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADD_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 82);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4412,7 +4417,7 @@ private:
         }
         else{
             if(rd!=0){
-                cc.mov(get_ptr_for(jh, traits::X0+ rd),
+                mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(jh, 
                           (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rd), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, false));
@@ -4447,9 +4452,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JALR_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 83);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4459,12 +4464,12 @@ private:
         }
         else{
             auto new_pc = load_reg_from_mem(jh, traits::X0 + rs1);
-            cc.mov(get_ptr_for(jh, traits::X0+ 1),
+            mov(cc, get_ptr_for(jh, traits::X0+ 1),
                   (uint32_t)(PC+2));
             auto PC_val_v = gen_operation(jh, band, new_pc, ~ 1)
             ;
-            cc.mov(jh.next_pc, PC_val_v);
-            cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, jh.next_pc, PC_val_v);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         }
         auto returnValue = BRANCH;
         
@@ -4493,9 +4498,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__EBREAK_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 84);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4531,9 +4536,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SWSP_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 85);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4575,9 +4580,9 @@ private:
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DII_{:#x}:",pc.val).c_str());
         this->gen_sync(jh, PRE_SYNC, 86);
-        cc.mov(jh.pc, pc.val);
+        mov(cc, jh.pc, pc.val);
         pc = pc+2;
-        cc.mov(jh.next_pc, pc.val);
+        mov(cc, jh.next_pc, pc.val);
 
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
@@ -4697,9 +4702,9 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     cc.comment("//gen_instr_prologue");
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
-    cc.mov(get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
+    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    mov(cc, get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
 
 }
 template <typename ARCH>
@@ -4707,16 +4712,16 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_epilogue");
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
-    cc.cmp(current_trap_state, 0);
+    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
 
-    jh.pc = load_reg_from_mem(jh, traits::PC);
-    jh.next_pc = load_reg_from_mem(jh, traits::NEXT_PC);
+    jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
+    jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -4728,14 +4733,14 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     this->write_back(jh);
     this->gen_sync(jh, POST_SYNC, -1);
 
-    x86::Gp current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
+    x86::Gp current_trap_state = get_reg_for_Gp(jh, traits::TRAP_STATE);
+    mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
 
-    x86::Gp current_pc = get_reg_for(jh, traits::PC);
-    cc.mov(current_pc, get_ptr_for(jh, traits::PC));
+    x86::Gp current_pc = get_reg_for_Gp(jh, traits::PC);
+    mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
     x86::Gp instr = cc.newInt32("instr");
-    cc.mov(instr, 0); // FIXME:this is not correct
+    mov(cc, instr, 0); // FIXME:this is not correct, should be instrId of trapping instr
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
     cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
@@ -4744,11 +4749,11 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(2, current_pc);
     call_enter_trap->setArg(3, instr);
 
-    x86::Gp current_next_pc = get_reg_for(jh, traits::NEXT_PC);
-    cc.mov(current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
-    cc.mov(jh.next_pc, current_next_pc);
+    x86_reg_t current_next_pc = get_reg_for(jh, traits::NEXT_PC);
+    mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
+    mov(cc, jh.next_pc, current_next_pc);
 
-    cc.mov(get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
+    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
     cc.ret(jh.next_pc);
 }
 template <typename ARCH>
@@ -4756,9 +4761,9 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto& cc = jh.cc;
     cc.comment("//gen_raise");
     auto tmp1 = get_reg_for(jh, traits::TRAP_STATE);
-    cc.mov(tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
-    cc.mov(get_ptr_for(jh, traits::TRAP_STATE), tmp1);
-    cc.mov(jh.next_pc, std::numeric_limits<uint32_t>::max());
+    mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
+    mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
+    mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());
 }
 
 } // namespace tgc5c

From 55b0cea94f6e462f5fe521a306d5351b6763dd2b Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 3 Jul 2024 18:32:05 +0200
Subject: [PATCH 013/100] changes vm_base util API

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |  21 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 653 ++++++++++----------
 2 files changed, 338 insertions(+), 336 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 6a7a40e..6441884 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -95,6 +95,7 @@ protected:
     using super::gen_wait;
     using super::gen_leave;
     using super::gen_operation;
+    using super::gen_sync;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -160,7 +161,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("${instr.name}_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, ${idx});
+        gen_sync(jh, PRE_SYNC, ${idx});
         mov(cc, jh.pc, pc.val);
         pc = pc+${instr.length/8};
         mov(cc, jh.next_pc, pc.val);
@@ -171,7 +172,7 @@ private:
         <%instr.behavior.eachLine{%>${it}
         <%}%>
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, ${idx});
+        gen_sync(jh, POST_SYNC, ${idx});
     	return returnValue;        
     }
     <%}%>
@@ -181,12 +182,12 @@ private:
     continuation_e illegal_intruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("illegal_intruction{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, instr_descr.size());
+        gen_sync(jh, PRE_SYNC, instr_descr.size());
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, instr_descr.size());
+        gen_sync(jh, POST_SYNC, instr_descr.size());
         return BRANCH;
     }
      
@@ -282,7 +283,7 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     cc.comment("//gen_instr_prologue");
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
-    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     mov(cc, get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
 
@@ -292,7 +293,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_epilogue");
-    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
@@ -313,10 +314,10 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     this->write_back(jh);
     this->gen_sync(jh, POST_SYNC, -1);
 
-    x86::Gp current_trap_state = get_reg_for_Gp(jh, traits::TRAP_STATE);
+    x86::Gp current_trap_state = get_reg_for_Gp(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
 
-    x86::Gp current_pc = get_reg_for_Gp(jh, traits::PC);
+    x86::Gp current_pc = get_reg_for_Gp(cc, traits::PC);
     mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
     x86::Gp instr = cc.newInt32("instr");
@@ -329,7 +330,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(2, current_pc);
     call_enter_trap->setArg(3, instr);
 
-    x86_reg_t current_next_pc = get_reg_for(jh, traits::NEXT_PC);
+    x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
     mov(cc, jh.next_pc, current_next_pc);
 
@@ -340,7 +341,7 @@ template <typename ARCH>
 inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause) {
     auto& cc = jh.cc;
     cc.comment("//gen_raise");
-    auto tmp1 = get_reg_for(jh, traits::TRAP_STATE);
+    auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
     mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 4ba664e..8343ab8 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -95,6 +95,7 @@ protected:
     using super::gen_wait;
     using super::gen_leave;
     using super::gen_operation;
+    using super::gen_sync;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -335,7 +336,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LUI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 0);
+        gen_sync(jh, PRE_SYNC, 0);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -355,7 +356,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 0);
+        gen_sync(jh, POST_SYNC, 0);
     	return returnValue;        
     }
     
@@ -381,7 +382,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("AUIPC_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 1);
+        gen_sync(jh, PRE_SYNC, 1);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -401,7 +402,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 1);
+        gen_sync(jh, POST_SYNC, 1);
     	return returnValue;        
     }
     
@@ -427,7 +428,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("JAL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 2);
+        gen_sync(jh, PRE_SYNC, 2);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -455,7 +456,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 2);
+        gen_sync(jh, POST_SYNC, 2);
     	return returnValue;        
     }
     
@@ -482,7 +483,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("JALR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 3);
+        gen_sync(jh, PRE_SYNC, 3);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -495,12 +496,12 @@ private:
         }
         else{
             auto addr_mask = (uint32_t)- 2;
-            auto new_pc = gen_ext(jh, 
-                (gen_operation(jh, band, (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto new_pc = gen_ext(cc, 
+                (gen_operation(cc, band, (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), addr_mask)
                 ), 32, true);
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, urem, new_pc, static_cast<uint32_t>(traits::INSTR_ALIGNMENT))
+            cmp(cc, gen_operation(cc, urem, new_pc, static_cast<uint32_t>(traits::INSTR_ALIGNMENT))
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
@@ -523,7 +524,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 3);
+        gen_sync(jh, POST_SYNC, 3);
     	return returnValue;        
     }
     
@@ -550,7 +551,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BEQ_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 4);
+        gen_sync(jh, PRE_SYNC, 4);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -563,7 +564,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -581,7 +582,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 4);
+        gen_sync(jh, POST_SYNC, 4);
     	return returnValue;        
     }
     
@@ -608,7 +609,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BNE_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 5);
+        gen_sync(jh, PRE_SYNC, 5);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -621,7 +622,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -639,7 +640,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 5);
+        gen_sync(jh, POST_SYNC, 5);
     	return returnValue;        
     }
     
@@ -666,7 +667,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BLT_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 6);
+        gen_sync(jh, PRE_SYNC, 6);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -679,8 +680,8 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, lt, gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(jh, 
+            cmp(cc, gen_operation(cc, lt, gen_ext(cc, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false))
             ,0);
             cc.je(label_merge);
@@ -699,7 +700,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 6);
+        gen_sync(jh, POST_SYNC, 6);
     	return returnValue;        
     }
     
@@ -726,7 +727,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BGE_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 7);
+        gen_sync(jh, PRE_SYNC, 7);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -739,8 +740,8 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, gte, gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(jh, 
+            cmp(cc, gen_operation(cc, gte, gen_ext(cc, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false))
             ,0);
             cc.je(label_merge);
@@ -759,7 +760,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 7);
+        gen_sync(jh, POST_SYNC, 7);
     	return returnValue;        
     }
     
@@ -786,7 +787,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BLTU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 8);
+        gen_sync(jh, PRE_SYNC, 8);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -799,7 +800,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, ltu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(cc, ltu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -817,7 +818,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 8);
+        gen_sync(jh, POST_SYNC, 8);
     	return returnValue;        
     }
     
@@ -844,7 +845,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("BGEU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 9);
+        gen_sync(jh, PRE_SYNC, 9);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -857,7 +858,7 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, gteu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            cmp(cc, gen_operation(cc, gteu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
             cc.je(label_merge);
             {
@@ -875,7 +876,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 9);
+        gen_sync(jh, POST_SYNC, 9);
     	return returnValue;        
     }
     
@@ -902,7 +903,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LB_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 10);
+        gen_sync(jh, PRE_SYNC, 10);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -914,21 +915,21 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto load_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto load_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            auto res = gen_ext(jh, 
+            auto res = gen_ext(cc, 
                 gen_read_mem(jh, traits::MEM, load_address, 1), 8, false);
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 10);
+        gen_sync(jh, POST_SYNC, 10);
     	return returnValue;        
     }
     
@@ -955,7 +956,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LH_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 11);
+        gen_sync(jh, PRE_SYNC, 11);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -967,21 +968,21 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto load_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto load_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            auto res = gen_ext(jh, 
+            auto res = gen_ext(cc, 
                 gen_read_mem(jh, traits::MEM, load_address, 2), 16, false);
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 11);
+        gen_sync(jh, POST_SYNC, 11);
     	return returnValue;        
     }
     
@@ -1008,7 +1009,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LW_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 12);
+        gen_sync(jh, PRE_SYNC, 12);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1020,21 +1021,21 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto load_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto load_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            auto res = gen_ext(jh, 
+            auto res = gen_ext(cc, 
                 gen_read_mem(jh, traits::MEM, load_address, 4), 32, false);
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 12);
+        gen_sync(jh, POST_SYNC, 12);
     	return returnValue;        
     }
     
@@ -1061,7 +1062,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LBU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 13);
+        gen_sync(jh, PRE_SYNC, 13);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1073,20 +1074,20 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto load_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto load_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
             auto res = gen_read_mem(jh, traits::MEM, load_address, 1);
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, false));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 13);
+        gen_sync(jh, POST_SYNC, 13);
     	return returnValue;        
     }
     
@@ -1113,7 +1114,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("LHU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 14);
+        gen_sync(jh, PRE_SYNC, 14);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1125,20 +1126,20 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto load_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto load_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
             auto res = gen_read_mem(jh, traits::MEM, load_address, 2);
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, false));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 14);
+        gen_sync(jh, POST_SYNC, 14);
     	return returnValue;        
     }
     
@@ -1165,7 +1166,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SB_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 15);
+        gen_sync(jh, PRE_SYNC, 15);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1177,16 +1178,16 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto store_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto store_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            gen_write_mem(jh, traits::MEM, store_address, gen_ext(jh, 
+            gen_write_mem(jh, traits::MEM, store_address, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 8, false), 1);
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 15);
+        gen_sync(jh, POST_SYNC, 15);
     	return returnValue;        
     }
     
@@ -1213,7 +1214,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SH_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 16);
+        gen_sync(jh, PRE_SYNC, 16);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1225,16 +1226,16 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto store_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto store_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            gen_write_mem(jh, traits::MEM, store_address, gen_ext(jh, 
+            gen_write_mem(jh, traits::MEM, store_address, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 16, false), 2);
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 16);
+        gen_sync(jh, POST_SYNC, 16);
     	return returnValue;        
     }
     
@@ -1261,7 +1262,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SW_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 17);
+        gen_sync(jh, PRE_SYNC, 17);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1273,16 +1274,16 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto store_address = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+            auto store_address = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), 32, true);
-            gen_write_mem(jh, traits::MEM, store_address, gen_ext(jh, 
+            gen_write_mem(jh, traits::MEM, store_address, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false), 4);
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 17);
+        gen_sync(jh, POST_SYNC, 17);
     	return returnValue;        
     }
     
@@ -1309,7 +1310,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ADDI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 18);
+        gen_sync(jh, PRE_SYNC, 18);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1323,15 +1324,15 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
+                      gen_ext(cc, 
+                          (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                           ), 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 18);
+        gen_sync(jh, POST_SYNC, 18);
     	return returnValue;        
     }
     
@@ -1358,7 +1359,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 19);
+        gen_sync(jh, PRE_SYNC, 19);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1374,8 +1375,8 @@ private:
                 {
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(jh, 1);
-                cmp(cc, gen_ext(jh, 
+                auto tmp_reg = get_reg_for(cc, 1);
+                cmp(cc, gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (int16_t)sext<12>(imm));
                 cc.jl(label_then);
                 mov(cc, tmp_reg,0);
@@ -1384,7 +1385,7 @@ private:
                 mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, tmp_reg
+                      gen_ext(cc, tmp_reg
                       , 32, false)
                 );
                 }
@@ -1393,7 +1394,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 19);
+        gen_sync(jh, POST_SYNC, 19);
     	return returnValue;        
     }
     
@@ -1420,7 +1421,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTIU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 20);
+        gen_sync(jh, PRE_SYNC, 20);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1436,7 +1437,7 @@ private:
                 {
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(jh, 1);
+                auto tmp_reg = get_reg_for(cc, 1);
                 cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)));
                 cc.jb(label_then);
                 mov(cc, tmp_reg,0);
@@ -1445,7 +1446,7 @@ private:
                 mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, tmp_reg
+                      gen_ext(cc, tmp_reg
                       , 32, false)
                 );
                 }
@@ -1454,7 +1455,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 20);
+        gen_sync(jh, POST_SYNC, 20);
     	return returnValue;        
     }
     
@@ -1481,7 +1482,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("XORI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 21);
+        gen_sync(jh, PRE_SYNC, 21);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1495,14 +1496,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      gen_operation(cc, bxor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 21);
+        gen_sync(jh, POST_SYNC, 21);
     	return returnValue;        
     }
     
@@ -1529,7 +1530,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ORI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 22);
+        gen_sync(jh, PRE_SYNC, 22);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1543,14 +1544,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      gen_operation(cc, bor, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 22);
+        gen_sync(jh, POST_SYNC, 22);
     	return returnValue;        
     }
     
@@ -1577,7 +1578,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ANDI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 23);
+        gen_sync(jh, PRE_SYNC, 23);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1591,14 +1592,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
+                      gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 23);
+        gen_sync(jh, POST_SYNC, 23);
     	return returnValue;        
     }
     
@@ -1625,7 +1626,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLLI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 24);
+        gen_sync(jh, PRE_SYNC, 24);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1639,14 +1640,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
+                      gen_operation(cc, shl, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 24);
+        gen_sync(jh, POST_SYNC, 24);
     	return returnValue;        
     }
     
@@ -1673,7 +1674,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRLI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 25);
+        gen_sync(jh, PRE_SYNC, 25);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1687,14 +1688,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
+                      gen_operation(cc, shr, load_reg_from_mem(jh, traits::X0 + rs1), shamt)
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 25);
+        gen_sync(jh, POST_SYNC, 25);
     	return returnValue;        
     }
     
@@ -1721,7 +1722,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRAI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 26);
+        gen_sync(jh, PRE_SYNC, 26);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1735,8 +1736,8 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, sar, gen_ext(jh, 
+                      gen_ext(cc, 
+                          (gen_operation(cc, sar, gen_ext(cc, 
                               load_reg_from_mem(jh, traits::X0 + rs1), 32, true), shamt)
                           ), 32, false));
             }
@@ -1744,7 +1745,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 26);
+        gen_sync(jh, POST_SYNC, 26);
     	return returnValue;        
     }
     
@@ -1771,7 +1772,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ADD_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 27);
+        gen_sync(jh, PRE_SYNC, 27);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1785,15 +1786,15 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_ext(cc, 
+                          (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, false));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 27);
+        gen_sync(jh, POST_SYNC, 27);
     	return returnValue;        
     }
     
@@ -1820,7 +1821,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SUB_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 28);
+        gen_sync(jh, PRE_SYNC, 28);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1834,15 +1835,15 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_ext(cc, 
+                          (gen_operation(cc, sub, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 28);
+        gen_sync(jh, POST_SYNC, 28);
     	return returnValue;        
     }
     
@@ -1869,7 +1870,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 29);
+        gen_sync(jh, PRE_SYNC, 29);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1883,7 +1884,7 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      gen_ext(cc, gen_operation(cc, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
                       , 32, false));
             }
@@ -1891,7 +1892,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 29);
+        gen_sync(jh, POST_SYNC, 29);
     	return returnValue;        
     }
     
@@ -1918,7 +1919,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLT_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 30);
+        gen_sync(jh, PRE_SYNC, 30);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1934,9 +1935,9 @@ private:
                 {
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(jh, 1);
-                cmp(cc, gen_ext(jh, 
-                    load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                auto tmp_reg = get_reg_for(cc, 1);
+                cmp(cc, gen_ext(cc, 
+                    load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs2), 32, true));
                 cc.jl(label_then);
                 mov(cc, tmp_reg,0);
@@ -1945,7 +1946,7 @@ private:
                 mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, tmp_reg
+                      gen_ext(cc, tmp_reg
                       , 32, false)
                 );
                 }
@@ -1954,7 +1955,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 30);
+        gen_sync(jh, POST_SYNC, 30);
     	return returnValue;        
     }
     
@@ -1981,7 +1982,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SLTU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 31);
+        gen_sync(jh, PRE_SYNC, 31);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -1997,7 +1998,7 @@ private:
                 {
                 auto label_then = cc.newLabel();
                 auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(jh, 1);
+                auto tmp_reg = get_reg_for(cc, 1);
                 cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2));
                 cc.jb(label_then);
                 mov(cc, tmp_reg,0);
@@ -2006,7 +2007,7 @@ private:
                 mov(cc, tmp_reg,1);
                 cc.bind(label_merge);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, tmp_reg
+                      gen_ext(cc, tmp_reg
                       , 32, false)
                 );
                 }
@@ -2015,7 +2016,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 31);
+        gen_sync(jh, POST_SYNC, 31);
     	return returnValue;        
     }
     
@@ -2042,7 +2043,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("XOR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 32);
+        gen_sync(jh, PRE_SYNC, 32);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2056,14 +2057,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_operation(cc, bxor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 32);
+        gen_sync(jh, POST_SYNC, 32);
     	return returnValue;        
     }
     
@@ -2090,7 +2091,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 33);
+        gen_sync(jh, PRE_SYNC, 33);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2104,7 +2105,7 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      gen_ext(cc, gen_operation(cc, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
                       , 32, false));
             }
@@ -2112,7 +2113,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 33);
+        gen_sync(jh, POST_SYNC, 33);
     	return returnValue;        
     }
     
@@ -2139,7 +2140,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("SRA_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 34);
+        gen_sync(jh, PRE_SYNC, 34);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2153,9 +2154,9 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_ext(jh, gen_operation(jh, sar, gen_ext(jh, 
-                              load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      gen_ext(cc, 
+                          (gen_ext(cc, gen_operation(cc, sar, gen_ext(cc, 
+                              load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                           ))
                           , 32, true)), 32, true));
             }
@@ -2163,7 +2164,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 34);
+        gen_sync(jh, POST_SYNC, 34);
     	return returnValue;        
     }
     
@@ -2190,7 +2191,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("OR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 35);
+        gen_sync(jh, PRE_SYNC, 35);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2204,14 +2205,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_operation(cc, bor, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 35);
+        gen_sync(jh, POST_SYNC, 35);
     	return returnValue;        
     }
     
@@ -2238,7 +2239,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("AND_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 36);
+        gen_sync(jh, PRE_SYNC, 36);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2252,14 +2253,14 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 36);
+        gen_sync(jh, POST_SYNC, 36);
     	return returnValue;        
     }
     
@@ -2288,7 +2289,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("FENCE_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 37);
+        gen_sync(jh, PRE_SYNC, 37);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2300,7 +2301,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 37);
+        gen_sync(jh, POST_SYNC, 37);
     	return returnValue;        
     }
     
@@ -2323,7 +2324,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("ECALL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 38);
+        gen_sync(jh, PRE_SYNC, 38);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2335,7 +2336,7 @@ private:
         auto returnValue = TRAP;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 38);
+        gen_sync(jh, POST_SYNC, 38);
     	return returnValue;        
     }
     
@@ -2358,7 +2359,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("EBREAK_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 39);
+        gen_sync(jh, PRE_SYNC, 39);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2370,7 +2371,7 @@ private:
         auto returnValue = TRAP;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 39);
+        gen_sync(jh, POST_SYNC, 39);
     	return returnValue;        
     }
     
@@ -2393,7 +2394,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MRET_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 40);
+        gen_sync(jh, PRE_SYNC, 40);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2405,7 +2406,7 @@ private:
         auto returnValue = TRAP;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 40);
+        gen_sync(jh, POST_SYNC, 40);
     	return returnValue;        
     }
     
@@ -2428,7 +2429,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("WFI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 41);
+        gen_sync(jh, PRE_SYNC, 41);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2440,7 +2441,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 41);
+        gen_sync(jh, POST_SYNC, 41);
     	return returnValue;        
     }
     
@@ -2467,7 +2468,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRW_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 42);
+        gen_sync(jh, PRE_SYNC, 42);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2493,7 +2494,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 42);
+        gen_sync(jh, POST_SYNC, 42);
     	return returnValue;        
     }
     
@@ -2520,7 +2521,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRS_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 43);
+        gen_sync(jh, PRE_SYNC, 43);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2535,7 +2536,7 @@ private:
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
             auto xrs1 = load_reg_from_mem(jh, traits::X0 + rs1);
             if(rs1!=0){
-                gen_write_mem(jh, traits::CSR, csr, gen_operation(jh, bor, xrd, xrs1)
+                gen_write_mem(jh, traits::CSR, csr, gen_operation(cc, bor, xrd, xrs1)
                 , 4);
             }
             if(rd!=0){
@@ -2546,7 +2547,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 43);
+        gen_sync(jh, POST_SYNC, 43);
     	return returnValue;        
     }
     
@@ -2573,7 +2574,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRC_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 44);
+        gen_sync(jh, PRE_SYNC, 44);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2588,7 +2589,7 @@ private:
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
             auto xrs1 = load_reg_from_mem(jh, traits::X0 + rs1);
             if(rs1!=0){
-                gen_write_mem(jh, traits::CSR, csr, gen_operation(jh, band, xrd, gen_operation(jh, bnot, xrs1))
+                gen_write_mem(jh, traits::CSR, csr, gen_operation(cc, band, xrd, gen_operation(cc, bnot, xrs1))
                 , 4);
             }
             if(rd!=0){
@@ -2599,7 +2600,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 44);
+        gen_sync(jh, POST_SYNC, 44);
     	return returnValue;        
     }
     
@@ -2626,7 +2627,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRWI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 45);
+        gen_sync(jh, PRE_SYNC, 45);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2648,7 +2649,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 45);
+        gen_sync(jh, POST_SYNC, 45);
     	return returnValue;        
     }
     
@@ -2675,7 +2676,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRSI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 46);
+        gen_sync(jh, PRE_SYNC, 46);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2689,7 +2690,7 @@ private:
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
             if(zimm!=0){
-                gen_write_mem(jh, traits::CSR, csr, gen_operation(jh, bor, xrd, (uint32_t)zimm)
+                gen_write_mem(jh, traits::CSR, csr, gen_operation(cc, bor, xrd, (uint32_t)zimm)
                 , 4);
             }
             if(rd!=0){
@@ -2700,7 +2701,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 46);
+        gen_sync(jh, POST_SYNC, 46);
     	return returnValue;        
     }
     
@@ -2727,7 +2728,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("CSRRCI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 47);
+        gen_sync(jh, PRE_SYNC, 47);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2741,7 +2742,7 @@ private:
         else{
             auto xrd = gen_read_mem(jh, traits::CSR, csr, 4);
             if(zimm!=0){
-                gen_write_mem(jh, traits::CSR, csr, gen_operation(jh, band, xrd, ~ ((uint32_t)zimm))
+                gen_write_mem(jh, traits::CSR, csr, gen_operation(cc, band, xrd, ~ ((uint32_t)zimm))
                 , 4);
             }
             if(rd!=0){
@@ -2752,7 +2753,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 47);
+        gen_sync(jh, POST_SYNC, 47);
     	return returnValue;        
     }
     
@@ -2779,7 +2780,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("FENCE_I_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 48);
+        gen_sync(jh, PRE_SYNC, 48);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2791,7 +2792,7 @@ private:
         auto returnValue = FLUSH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 48);
+        gen_sync(jh, POST_SYNC, 48);
     	return returnValue;        
     }
     
@@ -2818,7 +2819,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MUL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 49);
+        gen_sync(jh, PRE_SYNC, 49);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2830,20 +2831,20 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, smul, gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+            auto res = gen_operation(cc, smul, gen_ext(cc, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
+                      gen_ext(cc, 
                           res, 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 49);
+        gen_sync(jh, POST_SYNC, 49);
     	return returnValue;        
     }
     
@@ -2870,7 +2871,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULH_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 50);
+        gen_sync(jh, PRE_SYNC, 50);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2882,21 +2883,21 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, smul, gen_ext(jh, 
-                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+            auto res = gen_operation(cc, smul, gen_ext(cc, 
+                load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
             ;
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
+                      gen_ext(cc, 
+                          (gen_operation(cc, sar, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 50);
+        gen_sync(jh, POST_SYNC, 50);
     	return returnValue;        
     }
     
@@ -2923,7 +2924,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULHSU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 51);
+        gen_sync(jh, PRE_SYNC, 51);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2935,20 +2936,20 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, sumul, gen_ext(jh, 
+            auto res = gen_operation(cc, sumul, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true), load_reg_from_mem(jh, traits::X0 + rs2))
             ;
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, sar, res, static_cast<uint32_t>(traits::XLEN))
+                      gen_ext(cc, 
+                          (gen_operation(cc, sar, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 51);
+        gen_sync(jh, POST_SYNC, 51);
     	return returnValue;        
     }
     
@@ -2975,7 +2976,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("MULHU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 52);
+        gen_sync(jh, PRE_SYNC, 52);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -2987,19 +2988,19 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res = gen_operation(jh, umul, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+            auto res = gen_operation(cc, umul, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ;
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, shr, res, static_cast<uint32_t>(traits::XLEN))
+                      gen_ext(cc, 
+                          (gen_operation(cc, shr, res, static_cast<uint32_t>(traits::XLEN))
                           ), 32, false));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 52);
+        gen_sync(jh, POST_SYNC, 52);
     	return returnValue;        
     }
     
@@ -3026,7 +3027,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DIV_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 53);
+        gen_sync(jh, PRE_SYNC, 53);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -3038,21 +3039,21 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto dividend = gen_ext(jh, 
+            auto dividend = gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, true);
-            auto divisor = gen_ext(jh, 
+            auto divisor = gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true);
             if(rd!=0){
                 auto label_merge = cc.newLabel();
-                cmp(cc, gen_operation(jh, ne, divisor, 0)
+                cmp(cc, gen_operation(cc, ne, divisor, 0)
                 ,0);
                 auto label_else = cc.newLabel();
                 cc.je(label_else);
                 {
                     auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
                     auto label_merge = cc.newLabel();
-                    cmp(cc, gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
-                    , gen_operation(jh, eq, divisor, - 1)
+                    cmp(cc, gen_operation(cc, land, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
+                    , gen_operation(cc, eq, divisor, - 1)
                     )
                     ,0);
                     auto label_else = cc.newLabel();
@@ -3065,8 +3066,8 @@ private:
                     cc.bind(label_else);
                         {
                             mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                                  gen_ext(jh, 
-                                      (gen_operation(jh, sdiv, dividend, divisor)
+                                  gen_ext(cc, 
+                                      (gen_operation(cc, sdiv, dividend, divisor)
                                       ), 32, true));
                         }
                     cc.bind(label_merge);
@@ -3083,7 +3084,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 53);
+        gen_sync(jh, POST_SYNC, 53);
     	return returnValue;        
     }
     
@@ -3110,7 +3111,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DIVU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 54);
+        gen_sync(jh, PRE_SYNC, 54);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -3123,14 +3124,14 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 if(rd!=0){
                     mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                          gen_operation(jh, udiv, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          gen_operation(cc, udiv, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           );
                 }
             }
@@ -3147,7 +3148,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 54);
+        gen_sync(jh, POST_SYNC, 54);
     	return returnValue;        
     }
     
@@ -3174,7 +3175,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("REM_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 55);
+        gen_sync(jh, PRE_SYNC, 55);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -3187,15 +3188,15 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto label_merge = cc.newLabel();
-                cmp(cc, gen_operation(jh, land, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
-                , gen_operation(jh, eq, gen_ext(jh, 
+                cmp(cc, gen_operation(cc, land, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
+                , gen_operation(cc, eq, gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs2), 32, false), - 1)
                 )
                 ,0);
@@ -3204,7 +3205,7 @@ private:
                 {
                     if(rd!=0){
                         mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                              gen_ext(jh, 0, 32, false)
+                              gen_ext(cc, 0, 32, false)
                         );
                     }
                 }
@@ -3213,9 +3214,9 @@ private:
                     {
                         if(rd!=0){
                             mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                                  gen_ext(jh, 
-                                      (gen_operation(jh, srem, gen_ext(jh, 
-                                          load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(jh, 
+                                  gen_ext(cc, 
+                                      (gen_operation(cc, srem, gen_ext(cc, 
+                                          load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(cc, 
                                           load_reg_from_mem(jh, traits::X0 + rs2), 32, true))
                                       ), 32, false));
                         }
@@ -3235,7 +3236,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 55);
+        gen_sync(jh, POST_SYNC, 55);
     	return returnValue;        
     }
     
@@ -3262,7 +3263,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("REMU_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 56);
+        gen_sync(jh, PRE_SYNC, 56);
         mov(cc, jh.pc, pc.val);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
@@ -3275,14 +3276,14 @@ private:
         }
         else{
             auto label_merge = cc.newLabel();
-            cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
+            cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
                 if(rd!=0){
                     mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                          gen_operation(jh, urem, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
+                          gen_operation(cc, urem, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
                           );
                 }
             }
@@ -3299,7 +3300,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 56);
+        gen_sync(jh, POST_SYNC, 56);
     	return returnValue;        
     }
     
@@ -3325,7 +3326,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI4SPN_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 57);
+        gen_sync(jh, PRE_SYNC, 57);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3335,8 +3336,8 @@ private:
         /*generate behavior*/
         if(imm){
             mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-                  gen_ext(jh, 
-                      (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), imm)
+                  gen_ext(cc, 
+                      (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + 2), imm)
                       ), 32, false));
         }
         else{
@@ -3345,7 +3346,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 57);
+        gen_sync(jh, POST_SYNC, 57);
     	return returnValue;        
     }
     
@@ -3372,7 +3373,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LW_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 58);
+        gen_sync(jh, PRE_SYNC, 58);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3380,17 +3381,17 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        auto offs = gen_ext(jh, 
-            (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
+        auto offs = gen_ext(cc, 
+            (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
             ), 32, false);
         mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-              gen_ext(jh, 
-                  gen_ext(jh, 
+              gen_ext(cc, 
+                  gen_ext(cc, 
                       gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 58);
+        gen_sync(jh, POST_SYNC, 58);
     	return returnValue;        
     }
     
@@ -3417,7 +3418,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SW_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 59);
+        gen_sync(jh, PRE_SYNC, 59);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3425,15 +3426,15 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        auto offs = gen_ext(jh, 
-            (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
+        auto offs = gen_ext(cc, 
+            (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1+8), uimm)
             ), 32, false);
-        gen_write_mem(jh, traits::MEM, offs, gen_ext(jh, 
+        gen_write_mem(jh, traits::MEM, offs, gen_ext(cc, 
             load_reg_from_mem(jh, traits::X0 + rs2+8), 32, false), 4);
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 59);
+        gen_sync(jh, POST_SYNC, 59);
     	return returnValue;        
     }
     
@@ -3459,7 +3460,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 60);
+        gen_sync(jh, PRE_SYNC, 60);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3473,15 +3474,15 @@ private:
         else{
             if(rs1!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rs1),
-                      gen_ext(jh, 
-                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rs1), (int8_t)sext<6>(imm))
+                      gen_ext(cc, 
+                          (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int8_t)sext<6>(imm))
                           ), 32, true));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 60);
+        gen_sync(jh, POST_SYNC, 60);
     	return returnValue;        
     }
     
@@ -3505,7 +3506,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__NOP_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 61);
+        gen_sync(jh, PRE_SYNC, 61);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3516,7 +3517,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 61);
+        gen_sync(jh, POST_SYNC, 61);
     	return returnValue;        
     }
     
@@ -3541,7 +3542,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JAL_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 62);
+        gen_sync(jh, PRE_SYNC, 62);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3557,7 +3558,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 62);
+        gen_sync(jh, POST_SYNC, 62);
     	return returnValue;        
     }
     
@@ -3583,7 +3584,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 63);
+        gen_sync(jh, PRE_SYNC, 63);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3603,7 +3604,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 63);
+        gen_sync(jh, POST_SYNC, 63);
     	return returnValue;        
     }
     
@@ -3629,7 +3630,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LUI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 64);
+        gen_sync(jh, PRE_SYNC, 64);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3647,7 +3648,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 64);
+        gen_sync(jh, POST_SYNC, 64);
     	return returnValue;        
     }
     
@@ -3672,7 +3673,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADDI16SP_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 65);
+        gen_sync(jh, PRE_SYNC, 65);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3682,8 +3683,8 @@ private:
         /*generate behavior*/
         if(nzimm){
             mov(cc, get_ptr_for(jh, traits::X0+ 2),
-                  gen_ext(jh, 
-                      (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), (int16_t)sext<10>(nzimm))
+                  gen_ext(cc, 
+                      (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + 2), (int16_t)sext<10>(nzimm))
                       ), 32, true));
         }
         else{
@@ -3692,7 +3693,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 65);
+        gen_sync(jh, POST_SYNC, 65);
     	return returnValue;        
     }
     
@@ -3716,7 +3717,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("__reserved_clui_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 66);
+        gen_sync(jh, PRE_SYNC, 66);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3728,7 +3729,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 66);
+        gen_sync(jh, POST_SYNC, 66);
     	return returnValue;        
     }
     
@@ -3754,7 +3755,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SRLI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 67);
+        gen_sync(jh, PRE_SYNC, 67);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3763,12 +3764,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
-              gen_operation(jh, shr, load_reg_from_mem(jh, traits::X0 + rs1+8), shamt)
+              gen_operation(cc, shr, load_reg_from_mem(jh, traits::X0 + rs1+8), shamt)
               );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 67);
+        gen_sync(jh, POST_SYNC, 67);
     	return returnValue;        
     }
     
@@ -3794,7 +3795,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SRAI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 68);
+        gen_sync(jh, PRE_SYNC, 68);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3804,16 +3805,16 @@ private:
         /*generate behavior*/
         if(shamt){
             mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
-                  gen_ext(jh, 
-                      (gen_operation(jh, sar, (gen_ext(jh, 
+                  gen_ext(cc, 
+                      (gen_operation(cc, sar, (gen_ext(cc, 
                           load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), shamt)
                       ), 32, true));
         }
         else{
             if(static_cast<uint32_t>(traits::XLEN)==128){
                 mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
-                      gen_ext(jh, 
-                          (gen_operation(jh, sar, (gen_ext(jh, 
+                      gen_ext(cc, 
+                          (gen_operation(cc, sar, (gen_ext(cc, 
                               load_reg_from_mem(jh, traits::X0 + rs1+8), 32, false)), 64)
                           ), 32, true));
             }
@@ -3821,7 +3822,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 68);
+        gen_sync(jh, POST_SYNC, 68);
     	return returnValue;        
     }
     
@@ -3847,7 +3848,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ANDI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 69);
+        gen_sync(jh, PRE_SYNC, 69);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3856,13 +3857,13 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rs1+8),
-              gen_ext(jh, 
-                  (gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1+8), (int8_t)sext<6>(imm))
+              gen_ext(cc, 
+                  (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1+8), (int8_t)sext<6>(imm))
                   ), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 69);
+        gen_sync(jh, POST_SYNC, 69);
     	return returnValue;        
     }
     
@@ -3888,7 +3889,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SUB_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 70);
+        gen_sync(jh, PRE_SYNC, 70);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3897,13 +3898,13 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-              gen_ext(jh, 
-                  (gen_operation(jh, sub, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              gen_ext(cc, 
+                  (gen_operation(cc, sub, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
                   ), 32, true));
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 70);
+        gen_sync(jh, POST_SYNC, 70);
     	return returnValue;        
     }
     
@@ -3929,7 +3930,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__XOR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 71);
+        gen_sync(jh, PRE_SYNC, 71);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3938,12 +3939,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-              gen_operation(jh, bxor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              gen_operation(cc, bxor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 71);
+        gen_sync(jh, POST_SYNC, 71);
     	return returnValue;        
     }
     
@@ -3969,7 +3970,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__OR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 72);
+        gen_sync(jh, PRE_SYNC, 72);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -3978,12 +3979,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-              gen_operation(jh, bor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              gen_operation(cc, bor, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 72);
+        gen_sync(jh, POST_SYNC, 72);
     	return returnValue;        
     }
     
@@ -4009,7 +4010,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__AND_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 73);
+        gen_sync(jh, PRE_SYNC, 73);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4018,12 +4019,12 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(cc, get_ptr_for(jh, traits::X0+ rd+8),
-              gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
+              gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rd+8), load_reg_from_mem(jh, traits::X0 + rs2+8))
               );
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 73);
+        gen_sync(jh, POST_SYNC, 73);
     	return returnValue;        
     }
     
@@ -4048,7 +4049,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__J_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 74);
+        gen_sync(jh, PRE_SYNC, 74);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4062,7 +4063,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 74);
+        gen_sync(jh, POST_SYNC, 74);
     	return returnValue;        
     }
     
@@ -4088,7 +4089,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__BEQZ_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 75);
+        gen_sync(jh, PRE_SYNC, 75);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4097,7 +4098,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         auto label_merge = cc.newLabel();
-        cmp(cc, gen_operation(jh, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
+        cmp(cc, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
         cc.je(label_merge);
         {
@@ -4109,7 +4110,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 75);
+        gen_sync(jh, POST_SYNC, 75);
     	return returnValue;        
     }
     
@@ -4135,7 +4136,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__BNEZ_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 76);
+        gen_sync(jh, PRE_SYNC, 76);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4144,7 +4145,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         auto label_merge = cc.newLabel();
-        cmp(cc, gen_operation(jh, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
+        cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
         cc.je(label_merge);
         {
@@ -4156,7 +4157,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 76);
+        gen_sync(jh, POST_SYNC, 76);
     	return returnValue;        
     }
     
@@ -4182,7 +4183,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SLLI_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 77);
+        gen_sync(jh, PRE_SYNC, 77);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4196,14 +4197,14 @@ private:
         else{
             if(rs1!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rs1),
-                      gen_operation(jh, shl, load_reg_from_mem(jh, traits::X0 + rs1), nzuimm)
+                      gen_operation(cc, shl, load_reg_from_mem(jh, traits::X0 + rs1), nzuimm)
                       );
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 77);
+        gen_sync(jh, POST_SYNC, 77);
     	return returnValue;        
     }
     
@@ -4229,7 +4230,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__LWSP_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 78);
+        gen_sync(jh, PRE_SYNC, 78);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4241,18 +4242,18 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto offs = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
+            auto offs = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
                 ), 32, false);
             mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                  gen_ext(jh, 
-                      gen_ext(jh, 
+                  gen_ext(cc, 
+                      gen_ext(cc, 
                           gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 78);
+        gen_sync(jh, POST_SYNC, 78);
     	return returnValue;        
     }
     
@@ -4278,7 +4279,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__MV_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 79);
+        gen_sync(jh, PRE_SYNC, 79);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4298,7 +4299,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 79);
+        gen_sync(jh, POST_SYNC, 79);
     	return returnValue;        
     }
     
@@ -4323,7 +4324,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 80);
+        gen_sync(jh, PRE_SYNC, 80);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4332,7 +4333,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){
-            auto PC_val_v = gen_operation(jh, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), ~ 1)
+            auto PC_val_v = gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), ~ 1)
             ;
             mov(cc, jh.next_pc, PC_val_v);
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
@@ -4343,7 +4344,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 80);
+        gen_sync(jh, POST_SYNC, 80);
     	return returnValue;        
     }
     
@@ -4366,7 +4367,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("__reserved_cmv_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 81);
+        gen_sync(jh, PRE_SYNC, 81);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4378,7 +4379,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 81);
+        gen_sync(jh, POST_SYNC, 81);
     	return returnValue;        
     }
     
@@ -4404,7 +4405,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__ADD_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 82);
+        gen_sync(jh, PRE_SYNC, 82);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4418,15 +4419,15 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(jh, 
-                          (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + rd), load_reg_from_mem(jh, traits::X0 + rs2))
+                      gen_ext(cc, 
+                          (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rd), load_reg_from_mem(jh, traits::X0 + rs2))
                           ), 32, false));
             }
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 82);
+        gen_sync(jh, POST_SYNC, 82);
     	return returnValue;        
     }
     
@@ -4451,7 +4452,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__JALR_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 83);
+        gen_sync(jh, PRE_SYNC, 83);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4466,7 +4467,7 @@ private:
             auto new_pc = load_reg_from_mem(jh, traits::X0 + rs1);
             mov(cc, get_ptr_for(jh, traits::X0+ 1),
                   (uint32_t)(PC+2));
-            auto PC_val_v = gen_operation(jh, band, new_pc, ~ 1)
+            auto PC_val_v = gen_operation(cc, band, new_pc, ~ 1)
             ;
             mov(cc, jh.next_pc, PC_val_v);
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
@@ -4474,7 +4475,7 @@ private:
         auto returnValue = BRANCH;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 83);
+        gen_sync(jh, POST_SYNC, 83);
     	return returnValue;        
     }
     
@@ -4497,7 +4498,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__EBREAK_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 84);
+        gen_sync(jh, PRE_SYNC, 84);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4509,7 +4510,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 84);
+        gen_sync(jh, POST_SYNC, 84);
     	return returnValue;        
     }
     
@@ -4535,7 +4536,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("C__SWSP_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 85);
+        gen_sync(jh, PRE_SYNC, 85);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4547,16 +4548,16 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto offs = gen_ext(jh, 
-                (gen_operation(jh, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
+            auto offs = gen_ext(cc, 
+                (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + 2), uimm)
                 ), 32, false);
-            gen_write_mem(jh, traits::MEM, offs, gen_ext(jh, 
+            gen_write_mem(jh, traits::MEM, offs, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, false), 4);
         }
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 85);
+        gen_sync(jh, POST_SYNC, 85);
     	return returnValue;        
     }
     
@@ -4579,7 +4580,7 @@ private:
         }
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("DII_{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, 86);
+        gen_sync(jh, PRE_SYNC, 86);
         mov(cc, jh.pc, pc.val);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
@@ -4591,7 +4592,7 @@ private:
         auto returnValue = CONT;
         
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, 86);
+        gen_sync(jh, POST_SYNC, 86);
     	return returnValue;        
     }
     
@@ -4601,12 +4602,12 @@ private:
     continuation_e illegal_intruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
         x86::Compiler& cc = jh.cc;
         cc.comment(fmt::format("illegal_intruction{:#x}:",pc.val).c_str());
-        this->gen_sync(jh, PRE_SYNC, instr_descr.size());
+        gen_sync(jh, PRE_SYNC, instr_descr.size());
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         gen_instr_epilogue(jh);
-        this->gen_sync(jh, POST_SYNC, instr_descr.size());
+        gen_sync(jh, POST_SYNC, instr_descr.size());
         return BRANCH;
     }
      
@@ -4702,7 +4703,7 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     cc.comment("//gen_instr_prologue");
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
-    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     mov(cc, get_ptr_for(jh, traits::PENDING_TRAP), current_trap_state);
 
@@ -4712,7 +4713,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_epilogue");
-    x86_reg_t current_trap_state = get_reg_for(jh, traits::TRAP_STATE);
+    x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
@@ -4733,10 +4734,10 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     this->write_back(jh);
     this->gen_sync(jh, POST_SYNC, -1);
 
-    x86::Gp current_trap_state = get_reg_for_Gp(jh, traits::TRAP_STATE);
+    x86::Gp current_trap_state = get_reg_for_Gp(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
 
-    x86::Gp current_pc = get_reg_for_Gp(jh, traits::PC);
+    x86::Gp current_pc = get_reg_for_Gp(cc, traits::PC);
     mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
     x86::Gp instr = cc.newInt32("instr");
@@ -4749,7 +4750,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(2, current_pc);
     call_enter_trap->setArg(3, instr);
 
-    x86_reg_t current_next_pc = get_reg_for(jh, traits::NEXT_PC);
+    x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
     mov(cc, jh.next_pc, current_next_pc);
 
@@ -4760,7 +4761,7 @@ template <typename ARCH>
 inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause) {
     auto& cc = jh.cc;
     cc.comment("//gen_raise");
-    auto tmp1 = get_reg_for(jh, traits::TRAP_STATE);
+    auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
     mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());

From 373145478e4ecfa717bc6a96867d146969f5e942 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 8 Jul 2024 10:40:03 +0200
Subject: [PATCH 014/100] updats file because of generator changes

---
 src/vm/asmjit/vm_tgc5c.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 8343ab8..d776a6c 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -1884,9 +1884,9 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, gen_operation(cc, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      gen_operation(cc, shl, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
-                      , 32, false));
+                      );
             }
         }
         auto returnValue = CONT;
@@ -2105,9 +2105,9 @@ private:
         else{
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, gen_operation(cc, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
+                      gen_operation(cc, shr, load_reg_from_mem(jh, traits::X0 + rs1), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                       ))
-                      , 32, false));
+                      );
             }
         }
         auto returnValue = CONT;
@@ -2155,10 +2155,10 @@ private:
             if(rd!=0){
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
                       gen_ext(cc, 
-                          (gen_ext(cc, gen_operation(cc, sar, gen_ext(cc, 
+                          (gen_operation(cc, sar, gen_ext(cc, 
                               load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs2), (static_cast<uint32_t>(traits::XLEN)-1))
                           ))
-                          , 32, true)), 32, true));
+                          ), 32, true));
             }
         }
         auto returnValue = CONT;

From b2cbf90d0b38eea8927cc014dda9eaf5cdfb58be Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 8 Jul 2024 12:05:27 +0200
Subject: [PATCH 015/100] updates generated files

---
 src/iss/arch/tgc5c.h       |  2 +-
 src/vm/interp/vm_tgc5c.cpp | 52 +++++++++++++++++++-------------------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/iss/arch/tgc5c.h b/src/iss/arch/tgc5c.h
index 606256a..7d51456 100644
--- a/src/iss/arch/tgc5c.h
+++ b/src/iss/arch/tgc5c.h
@@ -53,7 +53,7 @@ template <> struct traits<tgc5c> {
     static constexpr std::array<const char*, 36> reg_aliases{
         {"zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", "pc", "next_pc", "priv", "dpc"}};
 
-    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, FLEN=0ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
+    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
 
     constexpr static unsigned FP_REGS_SIZE = 0;
 
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 70b1195..a8d1e8f 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -732,9 +732,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int8_t res_40 = super::template read_mem<int8_t>(traits::MEM, load_address);
+                                        int8_t res_27 = super::template read_mem<int8_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int8_t res = (int8_t)res_40;
+                                        int8_t res = (int8_t)res_27;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -763,9 +763,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int16_t res_41 = super::template read_mem<int16_t>(traits::MEM, load_address);
+                                        int16_t res_28 = super::template read_mem<int16_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int16_t res = (int16_t)res_41;
+                                        int16_t res = (int16_t)res_28;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -794,9 +794,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        int32_t res_42 = super::template read_mem<int32_t>(traits::MEM, load_address);
+                                        int32_t res_29 = super::template read_mem<int32_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        int32_t res = (int32_t)res_42;
+                                        int32_t res = (int32_t)res_29;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -825,9 +825,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        uint8_t res_43 = super::template read_mem<uint8_t>(traits::MEM, load_address);
+                                        uint8_t res_30 = super::template read_mem<uint8_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint8_t res = res_43;
+                                        uint8_t res = res_30;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -856,9 +856,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         uint32_t load_address = (uint32_t)((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) ));
-                                        uint16_t res_44 = super::template read_mem<uint16_t>(traits::MEM, load_address);
+                                        uint16_t res_31 = super::template read_mem<uint16_t>(traits::MEM, load_address);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint16_t res = res_44;
+                                        uint16_t res = res_31;
                                         if(rd != 0) {
                                             *(X+rd) = (uint32_t)res;
                                         }
@@ -1556,9 +1556,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     else {
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rd != 0) {
-                                            uint32_t res_45 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                            uint32_t res_32 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                            uint32_t xrd = res_45;
+                                            uint32_t xrd = res_32;
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrs1);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
                                             *(X+rd) = xrd;
@@ -1591,9 +1591,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_46 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_33 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_46;
+                                        uint32_t xrd = res_33;
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rs1 != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd | xrs1);
@@ -1626,9 +1626,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_47 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_34 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_47;
+                                        uint32_t xrd = res_34;
                                         uint32_t xrs1 = *(X+rs1);
                                         if(rs1 != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd & ~ xrs1);
@@ -1661,9 +1661,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_48 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_35 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_48;
+                                        uint32_t xrd = res_35;
                                         super::template write_mem<uint32_t>(traits::CSR, csr, (uint32_t)zimm);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
                                         if(rd != 0) {
@@ -1693,9 +1693,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_49 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_36 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_49;
+                                        uint32_t xrd = res_36;
                                         if(zimm != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd | (uint32_t)zimm);
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
@@ -1727,9 +1727,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        uint32_t res_50 = super::template read_mem<uint32_t>(traits::CSR, csr);
+                                        uint32_t res_37 = super::template read_mem<uint32_t>(traits::CSR, csr);
                                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                                        uint32_t xrd = res_50;
+                                        uint32_t xrd = res_37;
                                         if(zimm != 0) {
                                             super::template write_mem<uint32_t>(traits::CSR, csr, xrd & ~ ((uint32_t)zimm));
                                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
@@ -2064,9 +2064,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                         uint32_t offs = (uint32_t)((uint64_t)(*(X+rs1 + 8) ) + (uint64_t)(uimm ));
-                        int32_t res_51 = super::template read_mem<int32_t>(traits::MEM, offs);
+                        int32_t res_38 = super::template read_mem<int32_t>(traits::MEM, offs);
                         if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                        *(X+rd + 8) = (uint32_t)(int32_t)res_51;
+                        *(X+rd + 8) = (uint32_t)(int32_t)res_38;
                     }
                     break;
                 }// @suppress("No break at end of case")
@@ -2486,9 +2486,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                         }
                         else {
                             uint32_t offs = (uint32_t)((uint64_t)(*(X+2) ) + (uint64_t)(uimm ));
-                            int32_t res_52 = super::template read_mem<int32_t>(traits::MEM, offs);
+                            int32_t res_39 = super::template read_mem<int32_t>(traits::MEM, offs);
                             if(this->core.reg.trap_state>=0x80000000UL) throw memory_access_exception();
-                            *(X+rd) = (uint32_t)(int32_t)res_52;
+                            *(X+rd) = (uint32_t)(int32_t)res_39;
                         }
                     }
                     break;

From ac8f8b05394ea0a6e32001ea98a47838ad2e941b Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 10 Jul 2024 12:43:43 +0200
Subject: [PATCH 016/100] updates vms with fixed Zc in tgc5c.core_desc

---
 src/vm/asmjit/vm_tgc5c.cpp |   6 +-
 src/vm/llvm/vm_tgc5c.cpp   | 232 ++++++++++++++++---------------------
 src/vm/tcc/vm_tgc5c.cpp    | 166 +++++++++++++-------------
 3 files changed, 189 insertions(+), 215 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index d776a6c..1a0fbba 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4333,7 +4333,8 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){
-            auto PC_val_v = gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), ~ 1)
+            auto addr_mask = (uint32_t)- 2;
+            auto PC_val_v = gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), addr_mask)
             ;
             mov(cc, jh.next_pc, PC_val_v);
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
@@ -4464,10 +4465,11 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            auto addr_mask = (uint32_t)- 2;
             auto new_pc = load_reg_from_mem(jh, traits::X0 + rs1);
             mov(cc, get_ptr_for(jh, traits::X0+ 1),
                   (uint32_t)(PC+2));
-            auto PC_val_v = gen_operation(cc, band, new_pc, ~ 1)
+            auto PC_val_v = gen_operation(cc, band, new_pc, addr_mask)
             ;
             mov(cc, jh.next_pc, PC_val_v);
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index aa4d9a0..7411353 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017, 2018 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -352,7 +352,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -395,7 +395,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -438,7 +438,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
@@ -489,7 +489,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto addr_mask =this->gen_const(32,(uint32_t)- 2);
@@ -563,7 +563,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -620,7 +620,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -677,7 +677,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -738,7 +738,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -799,7 +799,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -856,7 +856,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -913,7 +913,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address =this->gen_ext(
@@ -968,7 +968,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address =this->gen_ext(
@@ -1023,7 +1023,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address =this->gen_ext(
@@ -1078,7 +1078,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address =this->gen_ext(
@@ -1131,7 +1131,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto load_address =this->gen_ext(
@@ -1184,7 +1184,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address =this->gen_ext(
@@ -1234,7 +1234,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address =this->gen_ext(
@@ -1284,7 +1284,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto store_address =this->gen_ext(
@@ -1334,7 +1334,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1383,7 +1383,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1434,7 +1434,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1484,7 +1484,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1531,7 +1531,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1578,7 +1578,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1625,7 +1625,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1672,7 +1672,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1719,7 +1719,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1729,8 +1729,7 @@ private:
                             this->gen_ext(
                                 this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
                             this->gen_ext(this->gen_const(8,shamt), 32,false))
-                         ),
-                         32, true),
+                         ), 32,false),
                      get_reg_ptr(rd + traits::X0), false);
             }
         }
@@ -1769,7 +1768,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1818,7 +1817,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1867,7 +1866,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1917,7 +1916,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -1969,7 +1968,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2019,7 +2018,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2066,7 +2065,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2116,7 +2115,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2169,7 +2168,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2216,7 +2215,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -2398,7 +2397,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrs1 =this->gen_reg_load(rs1+ traits::X0, 0);
@@ -2451,7 +2450,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
@@ -2505,7 +2504,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
@@ -2559,7 +2558,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
@@ -2607,7 +2606,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
@@ -2660,7 +2659,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
@@ -2750,21 +2749,15 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res =this->gen_ext(
-                (this->builder.CreateMul(
-                   this->gen_ext(this->gen_ext(
-                       this->gen_ext(
-                           this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                       64, true), 128,true),
-                   this->gen_ext(this->gen_ext(
-                       this->gen_ext(
-                           this->gen_reg_load(rs2+ traits::X0, 0), 32,true),
-                       64, true), 128,true))
-                ),
-                64, true);
+            auto res =this->builder.CreateMul(
+               this->gen_ext(this->gen_ext(
+                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
+               this->gen_ext(this->gen_ext(
+                   this->gen_reg_load(rs2+ traits::X0, 0), 32,true), 64,true))
+            ;
             if(rd!=0) {
                 this->builder.CreateStore(
                      this->gen_ext(
@@ -2808,21 +2801,15 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res =this->gen_ext(
-                (this->builder.CreateMul(
-                   this->gen_ext(this->gen_ext(
-                       this->gen_ext(
-                           this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                       64, true), 128,true),
-                   this->gen_ext(this->gen_ext(
-                       this->gen_ext(
-                           this->gen_reg_load(rs2+ traits::X0, 0), 32,true),
-                       64, true), 128,true))
-                ),
-                64, true);
+            auto res =this->builder.CreateMul(
+               this->gen_ext(this->gen_ext(
+                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
+               this->gen_ext(this->gen_ext(
+                   this->gen_reg_load(rs2+ traits::X0, 0), 32,true), 64,true))
+            ;
             if(rd!=0) {
                 this->builder.CreateStore(
                      this->gen_ext(
@@ -2869,20 +2856,14 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res =this->gen_ext(
-                (this->builder.CreateMul(
-                   this->gen_ext(this->gen_ext(
-                       this->gen_ext(
-                           this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                       64, true), 128,true),
-                   this->gen_ext(this->gen_ext(
-                       this->gen_reg_load(rs2+ traits::X0, 0),
-                       64, false), 128,false))
-                ),
-                64, true);
+            auto res =this->builder.CreateMul(
+               this->gen_ext(this->gen_ext(
+                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
+               this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
+            ;
             if(rd!=0) {
                 this->builder.CreateStore(
                      this->gen_ext(
@@ -2929,19 +2910,13 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto res =this->gen_ext(
-                (this->builder.CreateMul(
-                   this->gen_ext(this->gen_ext(
-                       this->gen_reg_load(rs1+ traits::X0, 0),
-                       64, false), 128,false),
-                   this->gen_ext(this->gen_ext(
-                       this->gen_reg_load(rs2+ traits::X0, 0),
-                       64, false), 128,false))
-                ),
-                64, false);
+            auto res =this->builder.CreateMul(
+               this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+               this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
+            ;
             if(rd!=0) {
                 this->builder.CreateStore(
                      this->gen_ext(
@@ -2988,15 +2963,13 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto dividend =this->gen_ext(
-                this->gen_reg_load(rs1+ traits::X0, 0),
-                32, false);
+                this->gen_reg_load(rs1+ traits::X0, 0), 32,true);
             auto divisor =this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0),
-                32, false);
+                this->gen_reg_load(rs2+ traits::X0, 0), 32,true);
             if(rd!=0){ auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3087,7 +3060,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -3101,12 +3074,10 @@ private:
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_ext(
-                             (this->builder.CreateUDiv(
-                                this->gen_reg_load(rs1+ traits::X0, 0),
-                                this->gen_reg_load(rs2+ traits::X0, 0))
-                             ),
-                             32, false),
+                         this->builder.CreateUDiv(
+                            this->gen_reg_load(rs1+ traits::X0, 0),
+                            this->gen_reg_load(rs2+ traits::X0, 0))
+                         ,
                          get_reg_ptr(rd + traits::X0), false);
                 }
             }
@@ -3157,7 +3128,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -3201,13 +3172,10 @@ private:
                              this->gen_ext(
                                  (this->builder.CreateSRem(
                                     this->gen_ext(
-                                        this->gen_reg_load(rs1+ traits::X0, 0),
-                                        32, false),
+                                        this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
                                     this->gen_ext(
-                                        this->gen_reg_load(rs2+ traits::X0, 0),
-                                        32, false))
-                                 ),
-                                 32, true),
+                                        this->gen_reg_load(rs2+ traits::X0, 0), 32,true))
+                                 ), 32,false),
                              get_reg_ptr(rd + traits::X0), false);
                     }
                 }
@@ -3261,7 +3229,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -3338,7 +3306,7 @@ private:
                  get_reg_ptr(rd+8 + traits::X0), false);
         }
         else{
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3466,7 +3434,7 @@ private:
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rs1!=0) {
@@ -3576,7 +3544,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -3619,7 +3587,7 @@ private:
 
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0) {
             this->builder.CreateStore(
@@ -3669,7 +3637,7 @@ private:
                  get_reg_ptr(2 + traits::X0), false);
         }
         else{
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3695,7 +3663,7 @@ private:
         this->gen_set_pc(pc, traits::NEXT_PC);
 
         /*generate behavior*/
-        this->gen_raise_trap(0, 2);
+        this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4154,7 +4122,7 @@ private:
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rs1!=0) {
@@ -4200,7 +4168,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto offs =this->gen_ext(
@@ -4251,7 +4219,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -4292,9 +4260,10 @@ private:
         this->gen_set_pc(pc, traits::NEXT_PC);
 
         /*generate behavior*/
-        if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto PC_val_v = this->builder.CreateAnd(
+        if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =this->gen_const(32,(uint32_t)- 2);
+        auto PC_val_v = this->builder.CreateAnd(
            this->gen_reg_load(rs1%static_cast<uint32_t>(traits::RFS)+ traits::X0, 0),
-           this->gen_const(32,~ 1))
+           addr_mask)
         ;
         this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
         this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
@@ -4360,7 +4329,7 @@ private:
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             if(rd!=0) {
@@ -4407,16 +4376,17 @@ private:
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            auto addr_mask =this->gen_const(32,(uint32_t)- 2);
             auto new_pc =this->gen_reg_load(rs1+ traits::X0, 0);
             this->builder.CreateStore(
                  this->gen_const(32,(uint32_t)(PC+2)),
                  get_reg_ptr(1 + traits::X0), false);
             auto PC_val_v = this->builder.CreateAnd(
                new_pc,
-               this->gen_const(32,~ 1))
+               addr_mask)
             ;
             this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
             this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
@@ -4479,7 +4449,7 @@ private:
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)) {
-            this->gen_raise_trap(0, 2);
+            this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
             auto offs =this->gen_ext(
@@ -4517,7 +4487,7 @@ private:
         this->gen_set_pc(pc, traits::NEXT_PC);
 
         /*generate behavior*/
-        this->gen_raise_trap(0, 2);
+        this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index cfc6375..b02372d 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2020 MINRES Technologies GmbH
+ * Copyright (C) 2020-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -346,7 +346,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -381,7 +381,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -416,7 +416,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
@@ -459,7 +459,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
@@ -510,7 +510,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
@@ -553,7 +553,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
@@ -596,7 +596,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
@@ -639,7 +639,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
@@ -682,7 +682,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
@@ -725,7 +725,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
@@ -768,7 +768,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
@@ -808,7 +808,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
@@ -848,7 +848,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
@@ -888,7 +888,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
@@ -928,7 +928,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
@@ -968,7 +968,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
@@ -1004,7 +1004,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
@@ -1040,7 +1040,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
@@ -1076,7 +1076,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1114,7 +1114,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1152,7 +1152,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1190,7 +1190,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1228,7 +1228,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1266,7 +1266,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1304,7 +1304,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1342,7 +1342,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1380,7 +1380,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1418,7 +1418,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1456,7 +1456,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1494,7 +1494,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1534,7 +1534,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1572,7 +1572,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1610,7 +1610,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1648,7 +1648,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1688,7 +1688,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1728,7 +1728,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1766,7 +1766,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -1922,7 +1922,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
@@ -1963,7 +1963,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
@@ -2006,7 +2006,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
@@ -2049,7 +2049,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
@@ -2087,7 +2087,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
@@ -2129,7 +2129,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
@@ -2199,12 +2199,12 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto res = tu.assignment(tu.ext((tu.mul(
-        	   tu.ext(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),64,true),
-        	   tu.ext(tu.ext(tu.load(rs2+ traits::X0, 0),32,true),64,true))),64,true),64);
+        	auto res = tu.assignment(tu.mul(
+        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
         	if(rd!=0) {
         	    tu.store(rd + traits::X0,
         	          tu.ext(res,32,false));
@@ -2238,12 +2238,12 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto res = tu.assignment(tu.ext((tu.mul(
-        	   tu.ext(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),64,true),
-        	   tu.ext(tu.ext(tu.load(rs2+ traits::X0, 0),32,true),64,true))),64,true),64);
+        	auto res = tu.assignment(tu.mul(
+        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
         	if(rd!=0) {
         	    tu.store(rd + traits::X0,
         	          tu.ext((tu.ashr(
@@ -2279,12 +2279,12 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto res = tu.assignment(tu.ext((tu.mul(
-        	   tu.ext(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),64,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),64,false))),64,true),64);
+        	auto res = tu.assignment(tu.mul(
+        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
+        	   tu.load(rs2+ traits::X0, 0)),64);
         	if(rd!=0) {
         	    tu.store(rd + traits::X0,
         	          tu.ext((tu.ashr(
@@ -2320,12 +2320,12 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto res = tu.assignment(tu.ext((tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),64,false),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),64,false))),64,false),64);
+        	auto res = tu.assignment(tu.mul(
+        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs2+ traits::X0, 0)),64);
         	if(rd!=0) {
         	    tu.store(rd + traits::X0,
         	          tu.ext((tu.lshr(
@@ -2361,7 +2361,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto dividend = tu.assignment(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),32);
@@ -2419,7 +2419,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
@@ -2427,9 +2427,9 @@ private:
         	   tu.constant(0,8)));
         	if(rd!=0) {
         	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.udiv(
+        	          tu.udiv(
         	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	             tu.load(rs2+ traits::X0, 0)));
         	}
         	tu.open_else();
         	if(rd!=0) {
@@ -2466,7 +2466,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
@@ -2527,7 +2527,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
@@ -2579,7 +2579,7 @@ private:
                      tu.constant(imm,16))),32,false));
         }
         else{
-        	this->gen_raise_trap(tu, 0, 2);
+        	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -2671,7 +2671,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rs1!=0) {
@@ -2760,7 +2760,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -2795,7 +2795,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(imm==0||rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0) {
             tu.store(rd + traits::X0,
@@ -2833,7 +2833,7 @@ private:
                      tu.constant((int16_t)sext<10>(nzimm),16))),32,false));
         }
         else{
-        	this->gen_raise_trap(tu, 0, 2);
+        	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -2857,7 +2857,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
-        this->gen_raise_trap(tu, 0, 2);
+        this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3197,7 +3197,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rs1!=0) {
@@ -3234,7 +3234,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rd==0) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
@@ -3270,7 +3270,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -3303,9 +3303,10 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
-        if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
+        if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
+        auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
            tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
-           tu.constant(~ 1,32)),32);
+           addr_mask),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }
@@ -3361,7 +3362,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	if(rd!=0) {
@@ -3397,15 +3398,16 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+        	auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
         	auto new_pc = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
         	tu.store(1 + traits::X0,
         	      tu.constant((uint32_t)(PC+2),32));
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
         	   new_pc,
-        	   tu.constant(~ 1,32)),32);
+        	   addr_mask),32);
         	tu.store(traits::NEXT_PC, PC_val_v);
         	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }
@@ -3458,7 +3460,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         if(rs2>=static_cast<uint32_t>(traits:: RFS)) {
-            this->gen_raise_trap(tu, 0, 2);
+            this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
@@ -3487,7 +3489,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
-        this->gen_raise_trap(tu, 0, 2);
+        this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();

From 149b3136d26ef0edbb810b24977c274079d35363 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 10 Jul 2024 12:55:36 +0200
Subject: [PATCH 017/100] updates generated files

---
 src/iss/arch/tgc5c.h       | 2 +-
 src/vm/asmjit/vm_tgc5c.cpp | 2 +-
 src/vm/interp/vm_tgc5c.cpp | 8 +++++---
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/iss/arch/tgc5c.h b/src/iss/arch/tgc5c.h
index 7d51456..606256a 100644
--- a/src/iss/arch/tgc5c.h
+++ b/src/iss/arch/tgc5c.h
@@ -53,7 +53,7 @@ template <> struct traits<tgc5c> {
     static constexpr std::array<const char*, 36> reg_aliases{
         {"zero", "ra", "sp", "gp", "tp", "t0", "t1", "t2", "s0", "s1", "a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7", "s2", "s3", "s4", "s5", "s6", "s7", "s8", "s9", "s10", "s11", "t3", "t4", "t5", "t6", "pc", "next_pc", "priv", "dpc"}};
 
-    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
+    enum constants {MISA_VAL=1073746180ULL, MARCHID_VAL=2147483651ULL, CLIC_NUM_IRQ=0ULL, XLEN=32ULL, FLEN=0ULL, INSTR_ALIGNMENT=2ULL, RFS=32ULL, fence=0ULL, fencei=1ULL, fencevmal=2ULL, fencevmau=3ULL, RV_CSR_FFLAGS=1ULL, RV_CSR_FRM=2ULL, RV_CSR_FCSR=3ULL, RV_CSR_UTVT=7ULL, RV_CSR_VSTART=8ULL, RV_CSR_VXSAT=9ULL, RV_CSR_VXRM=10ULL, RV_CSR_VCSR=15ULL, RV_CSR_SEED=21ULL, RV_CSR_UNXTI=69ULL, RV_CSR_UINTSTATUS=70ULL, RV_CSR_USCRATCHCSW=72ULL, RV_CSR_USCRATCHCSWL=73ULL, RV_CSR_SSTATUS=256ULL, RV_CSR_SEDELEG=258ULL, RV_CSR_SIDELEG=259ULL, RV_CSR_SIE=260ULL, RV_CSR_STVEC=261ULL, RV_CSR_SCOUNTEREN=262ULL, RV_CSR_STVT=263ULL, RV_CSR_SENVCFG=266ULL, RV_CSR_SSTATEEN0=268ULL, RV_CSR_SSTATEEN1=269ULL, RV_CSR_SSTATEEN2=270ULL, RV_CSR_SSTATEEN3=271ULL, RV_CSR_SSCRATCH=320ULL, RV_CSR_SEPC=321ULL, RV_CSR_SCAUSE=322ULL, RV_CSR_STVAL=323ULL, RV_CSR_SIP=324ULL, RV_CSR_SNXTI=325ULL, RV_CSR_SINTSTATUS=326ULL, RV_CSR_SSCRATCHCSW=328ULL, RV_CSR_SSCRATCHCSWL=329ULL, RV_CSR_STIMECMP=333ULL, RV_CSR_STIMECMPH=349ULL, RV_CSR_SATP=384ULL, RV_CSR_VSSTATUS=512ULL, RV_CSR_VSIE=516ULL, RV_CSR_VSTVEC=517ULL, RV_CSR_VSSCRATCH=576ULL, RV_CSR_VSEPC=577ULL, RV_CSR_VSCAUSE=578ULL, RV_CSR_VSTVAL=579ULL, RV_CSR_VSIP=580ULL, RV_CSR_VSTIMECMP=589ULL, RV_CSR_VSTIMECMPH=605ULL, RV_CSR_VSATP=640ULL, RV_CSR_MSTATUS=768ULL, RV_CSR_MISA=769ULL, RV_CSR_MEDELEG=770ULL, RV_CSR_MIDELEG=771ULL, RV_CSR_MIE=772ULL, RV_CSR_MTVEC=773ULL, RV_CSR_MCOUNTEREN=774ULL, RV_CSR_MTVT=775ULL, RV_CSR_MENVCFG=778ULL, RV_CSR_MSTATEEN0=780ULL, RV_CSR_MSTATEEN1=781ULL, RV_CSR_MSTATEEN2=782ULL, RV_CSR_MSTATEEN3=783ULL, RV_CSR_MSTATUSH=784ULL, RV_CSR_MENVCFGH=794ULL, RV_CSR_MSTATEEN0H=796ULL, RV_CSR_MSTATEEN1H=797ULL, RV_CSR_MSTATEEN2H=798ULL, RV_CSR_MSTATEEN3H=799ULL, RV_CSR_MCOUNTINHIBIT=800ULL, RV_CSR_MHPMEVENT3=803ULL, RV_CSR_MHPMEVENT4=804ULL, RV_CSR_MHPMEVENT5=805ULL, RV_CSR_MHPMEVENT6=806ULL, RV_CSR_MHPMEVENT7=807ULL, RV_CSR_MHPMEVENT8=808ULL, RV_CSR_MHPMEVENT9=809ULL, RV_CSR_MHPMEVENT10=810ULL, RV_CSR_MHPMEVENT11=811ULL, RV_CSR_MHPMEVENT12=812ULL, RV_CSR_MHPMEVENT13=813ULL, RV_CSR_MHPMEVENT14=814ULL, RV_CSR_MHPMEVENT15=815ULL, RV_CSR_MHPMEVENT16=816ULL, RV_CSR_MHPMEVENT17=817ULL, RV_CSR_MHPMEVENT18=818ULL, RV_CSR_MHPMEVENT19=819ULL, RV_CSR_MHPMEVENT20=820ULL, RV_CSR_MHPMEVENT21=821ULL, RV_CSR_MHPMEVENT22=822ULL, RV_CSR_MHPMEVENT23=823ULL, RV_CSR_MHPMEVENT24=824ULL, RV_CSR_MHPMEVENT25=825ULL, RV_CSR_MHPMEVENT26=826ULL, RV_CSR_MHPMEVENT27=827ULL, RV_CSR_MHPMEVENT28=828ULL, RV_CSR_MHPMEVENT29=829ULL, RV_CSR_MHPMEVENT30=830ULL, RV_CSR_MHPMEVENT31=831ULL, RV_CSR_MSCRATCH=832ULL, RV_CSR_MEPC=833ULL, RV_CSR_MCAUSE=834ULL, RV_CSR_MTVAL=835ULL, RV_CSR_MIP=836ULL, RV_CSR_MNXTI=837ULL, RV_CSR_MINTSTATUS=838ULL, RV_CSR_MSCRATCHCSW=840ULL, RV_CSR_MSCRATCHCSWL=841ULL, RV_CSR_MTINST=842ULL, RV_CSR_MTVAL2=843ULL, RV_CSR_PMPCFG0=928ULL, RV_CSR_PMPCFG1=929ULL, RV_CSR_PMPCFG2=930ULL, RV_CSR_PMPCFG3=931ULL, RV_CSR_PMPCFG4=932ULL, RV_CSR_PMPCFG5=933ULL, RV_CSR_PMPCFG6=934ULL, RV_CSR_PMPCFG7=935ULL, RV_CSR_PMPCFG8=936ULL, RV_CSR_PMPCFG9=937ULL, RV_CSR_PMPCFG10=938ULL, RV_CSR_PMPCFG11=939ULL, RV_CSR_PMPCFG12=940ULL, RV_CSR_PMPCFG13=941ULL, RV_CSR_PMPCFG14=942ULL, RV_CSR_PMPCFG15=943ULL, RV_CSR_PMPADDR0=944ULL, RV_CSR_PMPADDR1=945ULL, RV_CSR_PMPADDR2=946ULL, RV_CSR_PMPADDR3=947ULL, RV_CSR_PMPADDR4=948ULL, RV_CSR_PMPADDR5=949ULL, RV_CSR_PMPADDR6=950ULL, RV_CSR_PMPADDR7=951ULL, RV_CSR_PMPADDR8=952ULL, RV_CSR_PMPADDR9=953ULL, RV_CSR_PMPADDR10=954ULL, RV_CSR_PMPADDR11=955ULL, RV_CSR_PMPADDR12=956ULL, RV_CSR_PMPADDR13=957ULL, RV_CSR_PMPADDR14=958ULL, RV_CSR_PMPADDR15=959ULL, RV_CSR_PMPADDR16=960ULL, RV_CSR_PMPADDR17=961ULL, RV_CSR_PMPADDR18=962ULL, RV_CSR_PMPADDR19=963ULL, RV_CSR_PMPADDR20=964ULL, RV_CSR_PMPADDR21=965ULL, RV_CSR_PMPADDR22=966ULL, RV_CSR_PMPADDR23=967ULL, RV_CSR_PMPADDR24=968ULL, RV_CSR_PMPADDR25=969ULL, RV_CSR_PMPADDR26=970ULL, RV_CSR_PMPADDR27=971ULL, RV_CSR_PMPADDR28=972ULL, RV_CSR_PMPADDR29=973ULL, RV_CSR_PMPADDR30=974ULL, RV_CSR_PMPADDR31=975ULL, RV_CSR_PMPADDR32=976ULL, RV_CSR_PMPADDR33=977ULL, RV_CSR_PMPADDR34=978ULL, RV_CSR_PMPADDR35=979ULL, RV_CSR_PMPADDR36=980ULL, RV_CSR_PMPADDR37=981ULL, RV_CSR_PMPADDR38=982ULL, RV_CSR_PMPADDR39=983ULL, RV_CSR_PMPADDR40=984ULL, RV_CSR_PMPADDR41=985ULL, RV_CSR_PMPADDR42=986ULL, RV_CSR_PMPADDR43=987ULL, RV_CSR_PMPADDR44=988ULL, RV_CSR_PMPADDR45=989ULL, RV_CSR_PMPADDR46=990ULL, RV_CSR_PMPADDR47=991ULL, RV_CSR_PMPADDR48=992ULL, RV_CSR_PMPADDR49=993ULL, RV_CSR_PMPADDR50=994ULL, RV_CSR_PMPADDR51=995ULL, RV_CSR_PMPADDR52=996ULL, RV_CSR_PMPADDR53=997ULL, RV_CSR_PMPADDR54=998ULL, RV_CSR_PMPADDR55=999ULL, RV_CSR_PMPADDR56=1000ULL, RV_CSR_PMPADDR57=1001ULL, RV_CSR_PMPADDR58=1002ULL, RV_CSR_PMPADDR59=1003ULL, RV_CSR_PMPADDR60=1004ULL, RV_CSR_PMPADDR61=1005ULL, RV_CSR_PMPADDR62=1006ULL, RV_CSR_PMPADDR63=1007ULL, RV_CSR_SCONTEXT=1448ULL, RV_CSR_HSTATUS=1536ULL, RV_CSR_HEDELEG=1538ULL, RV_CSR_HIDELEG=1539ULL, RV_CSR_HIE=1540ULL, RV_CSR_HTIMEDELTA=1541ULL, RV_CSR_HCOUNTEREN=1542ULL, RV_CSR_HGEIE=1543ULL, RV_CSR_HENVCFG=1546ULL, RV_CSR_HSTATEEN0=1548ULL, RV_CSR_HSTATEEN1=1549ULL, RV_CSR_HSTATEEN2=1550ULL, RV_CSR_HSTATEEN3=1551ULL, RV_CSR_HTIMEDELTAH=1557ULL, RV_CSR_HENVCFGH=1562ULL, RV_CSR_HSTATEEN0H=1564ULL, RV_CSR_HSTATEEN1H=1565ULL, RV_CSR_HSTATEEN2H=1566ULL, RV_CSR_HSTATEEN3H=1567ULL, RV_CSR_HTVAL=1603ULL, RV_CSR_HIP=1604ULL, RV_CSR_HVIP=1605ULL, RV_CSR_HTINST=1610ULL, RV_CSR_HGATP=1664ULL, RV_CSR_HCONTEXT=1704ULL, RV_CSR_MHPMEVENT3H=1827ULL, RV_CSR_MHPMEVENT4H=1828ULL, RV_CSR_MHPMEVENT5H=1829ULL, RV_CSR_MHPMEVENT6H=1830ULL, RV_CSR_MHPMEVENT7H=1831ULL, RV_CSR_MHPMEVENT8H=1832ULL, RV_CSR_MHPMEVENT9H=1833ULL, RV_CSR_MHPMEVENT10H=1834ULL, RV_CSR_MHPMEVENT11H=1835ULL, RV_CSR_MHPMEVENT12H=1836ULL, RV_CSR_MHPMEVENT13H=1837ULL, RV_CSR_MHPMEVENT14H=1838ULL, RV_CSR_MHPMEVENT15H=1839ULL, RV_CSR_MHPMEVENT16H=1840ULL, RV_CSR_MHPMEVENT17H=1841ULL, RV_CSR_MHPMEVENT18H=1842ULL, RV_CSR_MHPMEVENT19H=1843ULL, RV_CSR_MHPMEVENT20H=1844ULL, RV_CSR_MHPMEVENT21H=1845ULL, RV_CSR_MHPMEVENT22H=1846ULL, RV_CSR_MHPMEVENT23H=1847ULL, RV_CSR_MHPMEVENT24H=1848ULL, RV_CSR_MHPMEVENT25H=1849ULL, RV_CSR_MHPMEVENT26H=1850ULL, RV_CSR_MHPMEVENT27H=1851ULL, RV_CSR_MHPMEVENT28H=1852ULL, RV_CSR_MHPMEVENT29H=1853ULL, RV_CSR_MHPMEVENT30H=1854ULL, RV_CSR_MHPMEVENT31H=1855ULL, RV_CSR_MSECCFG=1863ULL, RV_CSR_MSECCFGH=1879ULL, RV_CSR_TSELECT=1952ULL, RV_CSR_TDATA1=1953ULL, RV_CSR_TDATA2=1954ULL, RV_CSR_TDATA3=1955ULL, RV_CSR_TINFO=1956ULL, RV_CSR_TCONTROL=1957ULL, RV_CSR_MCONTEXT=1960ULL, RV_CSR_MSCONTEXT=1962ULL, RV_CSR_DCSR=1968ULL, RV_CSR_DPC=1969ULL, RV_CSR_DSCRATCH0=1970ULL, RV_CSR_DSCRATCH1=1971ULL, RV_CSR_MCYCLE=2816ULL, RV_CSR_MINSTRET=2818ULL, RV_CSR_MHPMCOUNTER3=2819ULL, RV_CSR_MHPMCOUNTER4=2820ULL, RV_CSR_MHPMCOUNTER5=2821ULL, RV_CSR_MHPMCOUNTER6=2822ULL, RV_CSR_MHPMCOUNTER7=2823ULL, RV_CSR_MHPMCOUNTER8=2824ULL, RV_CSR_MHPMCOUNTER9=2825ULL, RV_CSR_MHPMCOUNTER10=2826ULL, RV_CSR_MHPMCOUNTER11=2827ULL, RV_CSR_MHPMCOUNTER12=2828ULL, RV_CSR_MHPMCOUNTER13=2829ULL, RV_CSR_MHPMCOUNTER14=2830ULL, RV_CSR_MHPMCOUNTER15=2831ULL, RV_CSR_MHPMCOUNTER16=2832ULL, RV_CSR_MHPMCOUNTER17=2833ULL, RV_CSR_MHPMCOUNTER18=2834ULL, RV_CSR_MHPMCOUNTER19=2835ULL, RV_CSR_MHPMCOUNTER20=2836ULL, RV_CSR_MHPMCOUNTER21=2837ULL, RV_CSR_MHPMCOUNTER22=2838ULL, RV_CSR_MHPMCOUNTER23=2839ULL, RV_CSR_MHPMCOUNTER24=2840ULL, RV_CSR_MHPMCOUNTER25=2841ULL, RV_CSR_MHPMCOUNTER26=2842ULL, RV_CSR_MHPMCOUNTER27=2843ULL, RV_CSR_MHPMCOUNTER28=2844ULL, RV_CSR_MHPMCOUNTER29=2845ULL, RV_CSR_MHPMCOUNTER30=2846ULL, RV_CSR_MHPMCOUNTER31=2847ULL, RV_CSR_MCYCLEH=2944ULL, RV_CSR_MINSTRETH=2946ULL, RV_CSR_MHPMCOUNTER3H=2947ULL, RV_CSR_MHPMCOUNTER4H=2948ULL, RV_CSR_MHPMCOUNTER5H=2949ULL, RV_CSR_MHPMCOUNTER6H=2950ULL, RV_CSR_MHPMCOUNTER7H=2951ULL, RV_CSR_MHPMCOUNTER8H=2952ULL, RV_CSR_MHPMCOUNTER9H=2953ULL, RV_CSR_MHPMCOUNTER10H=2954ULL, RV_CSR_MHPMCOUNTER11H=2955ULL, RV_CSR_MHPMCOUNTER12H=2956ULL, RV_CSR_MHPMCOUNTER13H=2957ULL, RV_CSR_MHPMCOUNTER14H=2958ULL, RV_CSR_MHPMCOUNTER15H=2959ULL, RV_CSR_MHPMCOUNTER16H=2960ULL, RV_CSR_MHPMCOUNTER17H=2961ULL, RV_CSR_MHPMCOUNTER18H=2962ULL, RV_CSR_MHPMCOUNTER19H=2963ULL, RV_CSR_MHPMCOUNTER20H=2964ULL, RV_CSR_MHPMCOUNTER21H=2965ULL, RV_CSR_MHPMCOUNTER22H=2966ULL, RV_CSR_MHPMCOUNTER23H=2967ULL, RV_CSR_MHPMCOUNTER24H=2968ULL, RV_CSR_MHPMCOUNTER25H=2969ULL, RV_CSR_MHPMCOUNTER26H=2970ULL, RV_CSR_MHPMCOUNTER27H=2971ULL, RV_CSR_MHPMCOUNTER28H=2972ULL, RV_CSR_MHPMCOUNTER29H=2973ULL, RV_CSR_MHPMCOUNTER30H=2974ULL, RV_CSR_MHPMCOUNTER31H=2975ULL, RV_CSR_CYCLE=3072ULL, RV_CSR_TIME=3073ULL, RV_CSR_INSTRET=3074ULL, RV_CSR_HPMCOUNTER3=3075ULL, RV_CSR_HPMCOUNTER4=3076ULL, RV_CSR_HPMCOUNTER5=3077ULL, RV_CSR_HPMCOUNTER6=3078ULL, RV_CSR_HPMCOUNTER7=3079ULL, RV_CSR_HPMCOUNTER8=3080ULL, RV_CSR_HPMCOUNTER9=3081ULL, RV_CSR_HPMCOUNTER10=3082ULL, RV_CSR_HPMCOUNTER11=3083ULL, RV_CSR_HPMCOUNTER12=3084ULL, RV_CSR_HPMCOUNTER13=3085ULL, RV_CSR_HPMCOUNTER14=3086ULL, RV_CSR_HPMCOUNTER15=3087ULL, RV_CSR_HPMCOUNTER16=3088ULL, RV_CSR_HPMCOUNTER17=3089ULL, RV_CSR_HPMCOUNTER18=3090ULL, RV_CSR_HPMCOUNTER19=3091ULL, RV_CSR_HPMCOUNTER20=3092ULL, RV_CSR_HPMCOUNTER21=3093ULL, RV_CSR_HPMCOUNTER22=3094ULL, RV_CSR_HPMCOUNTER23=3095ULL, RV_CSR_HPMCOUNTER24=3096ULL, RV_CSR_HPMCOUNTER25=3097ULL, RV_CSR_HPMCOUNTER26=3098ULL, RV_CSR_HPMCOUNTER27=3099ULL, RV_CSR_HPMCOUNTER28=3100ULL, RV_CSR_HPMCOUNTER29=3101ULL, RV_CSR_HPMCOUNTER30=3102ULL, RV_CSR_HPMCOUNTER31=3103ULL, RV_CSR_VL=3104ULL, RV_CSR_VTYPE=3105ULL, RV_CSR_VLENB=3106ULL, RV_CSR_CYCLEH=3200ULL, RV_CSR_TIMEH=3201ULL, RV_CSR_INSTRETH=3202ULL, RV_CSR_HPMCOUNTER3H=3203ULL, RV_CSR_HPMCOUNTER4H=3204ULL, RV_CSR_HPMCOUNTER5H=3205ULL, RV_CSR_HPMCOUNTER6H=3206ULL, RV_CSR_HPMCOUNTER7H=3207ULL, RV_CSR_HPMCOUNTER8H=3208ULL, RV_CSR_HPMCOUNTER9H=3209ULL, RV_CSR_HPMCOUNTER10H=3210ULL, RV_CSR_HPMCOUNTER11H=3211ULL, RV_CSR_HPMCOUNTER12H=3212ULL, RV_CSR_HPMCOUNTER13H=3213ULL, RV_CSR_HPMCOUNTER14H=3214ULL, RV_CSR_HPMCOUNTER15H=3215ULL, RV_CSR_HPMCOUNTER16H=3216ULL, RV_CSR_HPMCOUNTER17H=3217ULL, RV_CSR_HPMCOUNTER18H=3218ULL, RV_CSR_HPMCOUNTER19H=3219ULL, RV_CSR_HPMCOUNTER20H=3220ULL, RV_CSR_HPMCOUNTER21H=3221ULL, RV_CSR_HPMCOUNTER22H=3222ULL, RV_CSR_HPMCOUNTER23H=3223ULL, RV_CSR_HPMCOUNTER24H=3224ULL, RV_CSR_HPMCOUNTER25H=3225ULL, RV_CSR_HPMCOUNTER26H=3226ULL, RV_CSR_HPMCOUNTER27H=3227ULL, RV_CSR_HPMCOUNTER28H=3228ULL, RV_CSR_HPMCOUNTER29H=3229ULL, RV_CSR_HPMCOUNTER30H=3230ULL, RV_CSR_HPMCOUNTER31H=3231ULL, RV_CSR_SCOUNTOVF=3488ULL, RV_CSR_HGEIP=3602ULL, RV_CSR_MVENDORID=3857ULL, RV_CSR_MARCHID=3858ULL, RV_CSR_MIMPID=3859ULL, RV_CSR_MHARTID=3860ULL, RV_CSR_MCONFIGPTR=3861ULL, RV_CAUSE_MISALIGNED_FETCH=0ULL, RV_CAUSE_FETCH_ACCESS=1ULL, RV_CAUSE_ILLEGAL_INSTRUCTION=2ULL, RV_CAUSE_BREAKPOINT=3ULL, RV_CAUSE_MISALIGNED_LOAD=4ULL, RV_CAUSE_LOAD_ACCESS=5ULL, RV_CAUSE_MISALIGNED_STORE=6ULL, RV_CAUSE_STORE_ACCESS=7ULL, RV_CAUSE_USER_ECALL=8ULL, RV_CAUSE_SUPERVISOR_ECALL=9ULL, RV_CAUSE_VIRTUAL_SUPERVISOR_ECALL=10ULL, RV_CAUSE_MACHINE_ECALL=11ULL, RV_CAUSE_FETCH_PAGE_FAULT=12ULL, RV_CAUSE_LOAD_PAGE_FAULT=13ULL, RV_CAUSE_STORE_PAGE_FAULT=15ULL, RV_CAUSE_FETCH_GUEST_PAGE_FAULT=20ULL, RV_CAUSE_LOAD_GUEST_PAGE_FAULT=21ULL, RV_CAUSE_VIRTUAL_INSTRUCTION=22ULL, RV_CAUSE_STORE_GUEST_PAGE_FAULT=23ULL, RV_MSTATUS_UIE=1ULL, RV_MSTATUS_SIE=2ULL, RV_MSTATUS_HIE=4ULL, RV_MSTATUS_MIE=8ULL, RV_MSTATUS_UPIE=16ULL, RV_MSTATUS_SPIE=32ULL, RV_MSTATUS_UBE=64ULL, RV_MSTATUS_MPIE=128ULL, RV_MSTATUS_SPP=256ULL, RV_MSTATUS_VS=1536ULL, RV_MSTATUS_MPP=6144ULL, RV_MSTATUS_FS=24576ULL, RV_MSTATUS_XS=98304ULL, RV_MSTATUS_MPRV=131072ULL, RV_MSTATUS_SUM=262144ULL, RV_MSTATUS_MXR=524288ULL, RV_MSTATUS_TVM=1048576ULL, RV_MSTATUS_TW=2097152ULL, RV_MSTATUS_TSR=4194304ULL, RV_MSTATUS32_SD=1ULL, RV_PRV_U=0ULL, RV_PRV_S=1ULL, RV_PRV_H=2ULL, RV_PRV_M=3ULL, RV_IRQ_U_SOFT=0ULL, RV_IRQ_S_SOFT=1ULL, RV_IRQ_VS_SOFT=2ULL, RV_IRQ_M_SOFT=3ULL, RV_IRQ_U_TIMER=4ULL, RV_IRQ_S_TIMER=5ULL, RV_IRQ_VS_TIMER=6ULL, RV_IRQ_M_TIMER=7ULL, RV_IRQ_U_EXT=8ULL, RV_IRQ_S_EXT=9ULL, RV_IRQ_VS_EXT=10ULL, RV_IRQ_M_EXT=11ULL, RV_IRQ_S_GEXT=12ULL, RV_IRQ_COP=12ULL, RV_IRQ_LCOF=13ULL, RV_MIP_USIP=1ULL, RV_MIP_SSIP=1ULL, RV_MIP_VSSIP=1ULL, RV_MIP_MSIP=1ULL, RV_MIP_UTIP=1ULL, RV_MIP_STIP=1ULL, RV_MIP_VSTIP=1ULL, RV_MIP_MTIP=1ULL, RV_MIP_UEIP=1ULL, RV_MIP_SEIP=1ULL, RV_MIP_VSEIP=1ULL, RV_MIP_MEIP=1ULL, RV_MIP_SGEIP=1ULL, RV_MIP_LCOFIP=1ULL, CSR_SIZE=4096ULL, MUL_LEN=64ULL};
 
     constexpr static unsigned FP_REGS_SIZE = 0;
 
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 1a0fbba..d2048ed 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4809,4 +4809,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
+// clang-format on
\ No newline at end of file
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index a8d1e8f..ee4edfb 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 20217-2024 MINRES Technologies GmbH
+ * Copyright (C) 2017-2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -2534,7 +2534,8 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     // execute instruction
                     {
                                     if(rs1 && rs1 < traits::RFS) {
-                                        *NEXT_PC = *(X+(uint32_t)(rs1 ) % traits::RFS) & (uint32_t)(~ 1 );
+                                        uint32_t addr_mask = (uint32_t)- 2;
+                                        *NEXT_PC = *(X+(uint32_t)(rs1 ) % traits::RFS) & addr_mask;
                                         this->core.reg.last_branch = 1;
                                     }
                                     else {
@@ -2600,9 +2601,10 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
+                                        uint32_t addr_mask = (uint32_t)- 2;
                                         uint32_t new_pc = *(X+rs1);
                                         *(X+1) = (uint32_t)((uint64_t)(*PC ) + (uint64_t)(2 ));
-                                        *NEXT_PC = new_pc & (uint32_t)(~ 1 );
+                                        *NEXT_PC = new_pc & addr_mask;
                                         this->core.reg.last_branch = 1;
                                     }
                                 }

From 9996fd483322c16c4c01b1aad3825c500d4cd383 Mon Sep 17 00:00:00 2001
From: stas <stas@minres.com>
Date: Thu, 11 Jul 2024 14:03:58 +0200
Subject: [PATCH 018/100] change cache line size to 64

---
 src/iss/arch/wt_cache.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/iss/arch/wt_cache.h b/src/iss/arch/wt_cache.h
index e762f22..967d464 100644
--- a/src/iss/arch/wt_cache.h
+++ b/src/iss/arch/wt_cache.h
@@ -87,7 +87,7 @@ public:
     virtual ~wt_cache() = default;
 
     unsigned size{4096};
-    unsigned line_sz{32};
+    unsigned line_sz{64};
     unsigned ways{1};
     uint64_t io_address{0xf0000000};
     uint64_t io_addr_mask{0xf0000000};

From 375755999a57cf8e3b52ab70a44e4ca769a2d223 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 16 Jul 2024 15:32:35 +0200
Subject: [PATCH 019/100] integrates new tval changes

---
 gen_input/templates/interp/CORENAME.cpp.gtl |  9 +++-
 src/iss/arch/riscv_hart_m_p.h               |  6 +--
 src/vm/interp/vm_tgc5c.cpp                  | 52 +++++++++++++++------
 3 files changed, 48 insertions(+), 19 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 567737d..2bd17fb 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -117,7 +117,12 @@ protected:
         this->core.wait_until(type);
     }
 
+    inline void set_tval(uint64_t new_tval){
+        tval = new_tval;
+    }
+
     uint64_t fetch_count{0};
+    uint64_t tval{0};
 
     using yield_t = boost::coroutines2::coroutine<void>::push_type;
     using coro_t = boost::coroutines2::coroutine<void>::pull_type;
@@ -341,7 +346,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
             //    this->core.reg.trap_state =  this->core.reg.pending_trap;
             // trap check
             if(trap_state!=0){
-                super::core.enter_trap(trap_state, pc.val, instr);
+                //In case of Instruction address misaligned (cause = 0 and trapid = 0) need the targeted addr (in tval)
+                auto mcause = (trap_state>>16) & 0xff; 
+                super::core.enter_trap(trap_state, pc.val, mcause ? instr:tval);
             } else {
                 icount++;
                 instret++;
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index d257d9c..e45f292 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -1207,7 +1207,7 @@ template <typename BASE, features_e FEAT> void riscv_hart_m_p<BASE, FEAT>::check
     }
 }
 
-template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t instr) {
+template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t tval) {
     // flags are ACTIVE[31:31], CAUSE[30:16], TRAPID[15:0]
     // calculate and write mcause val
     auto const trap_id = bit_sub<0, 16>(flags);
@@ -1228,10 +1228,10 @@ template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::e
          */
         switch(cause) {
         case 0:
-            csr[mtval] = static_cast<reg_t>(addr);
+            csr[mtval] = static_cast<reg_t>(tval);
             break;
         case 2:
-            csr[mtval] = (!has_compressed() || (instr & 0x3) == 3) ? instr : instr & 0xffff;
+            csr[mtval] = (!has_compressed() || (tval & 0x3) == 3) ? tval : tval & 0xffff;
             break;
         case 3:
             if((FEAT & FEAT_DEBUG) && (csr[dcsr] & 0x8000)) {
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index ee4edfb..0656c4b 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -113,7 +113,12 @@ protected:
         this->core.wait_until(type);
     }
 
+    inline void set_tval(uint64_t new_tval){
+        tval = new_tval;
+    }
+
     uint64_t fetch_count{0};
+    uint64_t tval{0};
 
     using yield_t = boost::coroutines2::coroutine<void>::push_type;
     using coro_t = boost::coroutines2::coroutine<void>::pull_type;
@@ -463,14 +468,16 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         raise(0, traits::RV_CAUSE_ILLEGAL_INSTRUCTION);
                                     }
                                     else {
-                                        if(imm % traits::INSTR_ALIGNMENT) {
+                                        uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int32_t)sext<21>(imm) ));
+                                        if(new_pc % traits::INSTR_ALIGNMENT) {
+                                            set_tval(new_pc);
                                             raise(0, 0);
                                         }
                                         else {
                                             if(rd != 0) {
                                                 *(X+rd) = (uint32_t)((uint64_t)(*PC ) + (uint64_t)(4 ));
                                             }
-                                            *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int32_t)sext<21>(imm) ));
+                                            *NEXT_PC = new_pc;
                                             this->core.reg.last_branch = 1;
                                         }
                                     }
@@ -500,6 +507,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                         uint32_t addr_mask = (uint32_t)- 2;
                                         uint32_t new_pc = (uint32_t)(((uint64_t)(*(X+rs1) ) + (uint64_t)((int16_t)sext<12>(imm) )) & (int64_t)(addr_mask ));
                                         if(new_pc % traits::INSTR_ALIGNMENT) {
+                                            set_tval(new_pc);
                                             raise(0, 0);
                                         }
                                         else {
@@ -534,11 +542,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if(*(X+rs1) == *(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -567,11 +577,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if(*(X+rs1) != *(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -600,11 +612,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if((int32_t)*(X+rs1) < (int32_t)*(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -633,11 +647,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if((int32_t)*(X+rs1) >= (int32_t)*(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -666,11 +682,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if(*(X+rs1) < *(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -699,11 +717,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                                     }
                                     else {
                                         if(*(X+rs1) >= *(X+rs2)) {
-                                            if((uint32_t)(imm ) % traits::INSTR_ALIGNMENT) {
+                                            uint32_t new_pc = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                            if(new_pc % traits::INSTR_ALIGNMENT) {
+                                                set_tval(new_pc);
                                                 raise(0, 0);
                                             }
                                             else {
-                                                *NEXT_PC = (uint32_t)((uint64_t)(*PC ) + (uint64_t)((int16_t)sext<13>(imm) ));
+                                                *NEXT_PC = new_pc;
                                                 this->core.reg.last_branch = 1;
                                             }
                                         }
@@ -2675,7 +2695,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
             //    this->core.reg.trap_state =  this->core.reg.pending_trap;
             // trap check
             if(trap_state!=0){
-                super::core.enter_trap(trap_state, pc.val, instr);
+                //In case of Instruction address misaligned (cause = 0 and trapid = 0) need the targeted addr (in tval)
+                auto mcause = (trap_state>>16) & 0xff; 
+                super::core.enter_trap(trap_state, pc.val, mcause ? instr:tval);
             } else {
                 icount++;
                 instret++;

From d8c3d2e19c105fd65633f082398c2cfcf4151da1 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 16 Jul 2024 17:35:23 +0200
Subject: [PATCH 020/100] integrates new tval changes into tcc

---
 contrib/instr/TGC5C_instr.yaml           |   2 +-
 gen_input/templates/tcc/CORENAME.cpp.gtl |  14 +-
 src/vm/tcc/vm_tgc5c.cpp                  | 233 +++++++++++++++++------
 3 files changed, 194 insertions(+), 55 deletions(-)

diff --git a/contrib/instr/TGC5C_instr.yaml b/contrib/instr/TGC5C_instr.yaml
index 1663d37..c28b051 100644
--- a/contrib/instr/TGC5C_instr.yaml
+++ b/contrib/instr/TGC5C_instr.yaml
@@ -20,7 +20,7 @@ RVI:
     mask: 0b00000000000000000000000001111111
     size:   32
     branch:   true
-    delay:   1
+    delay:   [1,1]
   JALR:
     index: 3
     encoding: 0b00000000000000000000000001100111
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index f736293..40db6d4 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -99,6 +99,10 @@ protected:
 
     void gen_wait(tu_builder& tu, unsigned type);
 
+    inline void gen_set_tval(tu_builder& tu, uint64_t new_tval);
+
+    inline void gen_set_tval(tu_builder& tu, value new_tval);
+
     inline void gen_trap_check(tu_builder& tu) {
         tu("if(*trap_state!=0) goto trap_entry;");
     }
@@ -169,6 +173,7 @@ private:
         pc=pc+ ${instr.length/8};
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         <%instr.behavior.eachLine{%>${it}
         <%}%>
         tu.close_scope();
@@ -304,10 +309,17 @@ template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsi
 template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
 }
 
+template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, uint64_t new_tval) {
+    tu(fmt::format("tval = {};", new_tval));
+}
+template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, value new_tval) {
+    tu(fmt::format("tval = {};", new_tval.str));
+}
+
 template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu("trap_entry:");
     this->gen_sync(tu, POST_SYNC, -1);    
-    tu("enter_trap(core_ptr, *trap_state, *pc, 0);");
+    tu("enter_trap(core_ptr, *trap_state, *pc, tval);");
     tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(),32));
     tu("return *next_pc;");
 }
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index b02372d..6483ec1 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -99,6 +99,10 @@ protected:
 
     void gen_wait(tu_builder& tu, unsigned type);
 
+    inline void gen_set_tval(tu_builder& tu, uint64_t new_tval);
+
+    inline void gen_set_tval(tu_builder& tu, value new_tval);
+
     inline void gen_trap_check(tu_builder& tu) {
         tu("if(*trap_state!=0) goto trap_entry;");
     }
@@ -345,6 +349,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -380,6 +385,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -415,21 +421,26 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		if(rd!=0) {
-        		    tu.store(rd + traits::X0,
-        		          tu.constant((uint32_t)(PC+4),32));
-        		}
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int32_t)sext<21>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int32_t)sext<21>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	if(rd!=0) {
+        	    tu.store(rd + traits::X0,
+        	          tu.constant((uint32_t)(PC+4),32));
         	}
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -458,6 +469,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -471,6 +483,7 @@ private:
         	tu.open_if(tu.urem(
         	   new_pc,
         	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
         	tu.open_else();
         	if(rd!=0) {
@@ -509,6 +522,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -516,13 +530,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -552,6 +570,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -559,13 +578,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -595,6 +618,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -602,13 +626,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
         	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -638,6 +666,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -645,13 +674,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
         	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -681,6 +714,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -688,13 +722,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -724,6 +762,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -731,13 +770,17 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	if(imm%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_raise_trap(tu, 0, 0);
-        	}
-        	else{
-        		auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<13>(imm)),32);
-        		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	}
+        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
+        	tu.open_if(tu.urem(
+        	   new_pc,
+        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	this->gen_set_tval(tu, new_pc);
+        	this->gen_raise_trap(tu, 0, 0);
+        	tu.open_else();
+        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        	tu.store(traits::NEXT_PC, PC_val_v);
+        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.close_scope();
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -767,6 +810,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -807,6 +851,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -847,6 +892,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -887,6 +933,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -927,6 +974,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -967,6 +1015,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1003,6 +1052,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1039,6 +1089,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1075,6 +1126,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1113,6 +1165,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1151,6 +1204,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1189,6 +1243,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1227,6 +1282,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1265,6 +1321,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1303,6 +1360,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1341,6 +1399,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1379,6 +1438,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1417,6 +1477,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1455,6 +1516,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1493,6 +1555,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1533,6 +1596,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1571,6 +1635,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1609,6 +1674,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1647,6 +1713,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1687,6 +1754,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1727,6 +1795,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1765,6 +1834,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1805,6 +1875,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.write_mem(traits::FENCE, static_cast<uint32_t>(traits:: fence), tu.constant((uint8_t)pred<<4|succ,8));
         auto returnValue = std::make_tuple(CONT);
         
@@ -1827,6 +1898,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, 11);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -1849,6 +1921,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, 3);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -1871,6 +1944,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_leave_trap(tu, 3);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -1893,6 +1967,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_wait(tu, 1);
         auto returnValue = std::make_tuple(CONT);
         
@@ -1921,6 +1996,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -1962,6 +2038,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2005,6 +2082,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2048,6 +2126,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2086,6 +2165,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2128,6 +2208,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2170,6 +2251,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.write_mem(traits::FENCE, static_cast<uint32_t>(traits:: fencei), tu.constant(imm,16));
         auto returnValue = std::make_tuple(FLUSH);
         
@@ -2198,6 +2280,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2237,6 +2320,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2278,6 +2362,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2319,6 +2404,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2360,6 +2446,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2418,6 +2505,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2465,6 +2553,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2526,6 +2615,7 @@ private:
         pc=pc+ 4;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)||rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2572,6 +2662,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(imm) {
             tu.store(rd+8 + traits::X0,
                   tu.ext((tu.add(
@@ -2608,6 +2699,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
@@ -2640,6 +2732,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
@@ -2670,6 +2763,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2703,6 +2797,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -2728,6 +2823,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(1 + traits::X0,
               tu.constant((uint32_t)(PC+2),32));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
@@ -2759,6 +2855,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2794,6 +2891,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(imm==0||rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -2826,6 +2924,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(nzimm) {
             tu.store(2 + traits::X0,
                   tu.ext((tu.add(
@@ -2857,6 +2956,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = std::make_tuple(CONT);
         
@@ -2884,6 +2984,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rs1+8 + traits::X0,
               tu.lshr(
                  tu.load(rs1+8+ traits::X0, 0),
@@ -2914,6 +3015,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(shamt){ tu.store(rs1+8 + traits::X0,
               tu.ext((tu.ashr(
                  (tu.ext(tu.load(rs1+8+ traits::X0, 0),32,true)),
@@ -2952,6 +3054,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rs1+8 + traits::X0,
               tu.ext((tu.bitwise_and(
                  tu.load(rs1+8+ traits::X0, 0),
@@ -2982,6 +3085,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rd+8 + traits::X0,
               tu.ext((tu.sub(
                  tu.load(rd+8+ traits::X0, 0),
@@ -3012,6 +3116,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rd+8 + traits::X0,
               tu.bitwise_xor(
                  tu.load(rd+8+ traits::X0, 0),
@@ -3042,6 +3147,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rd+8 + traits::X0,
               tu.bitwise_or(
                  tu.load(rd+8+ traits::X0, 0),
@@ -3072,6 +3178,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.store(rd+8 + traits::X0,
               tu.bitwise_and(
                  tu.load(rd+8+ traits::X0, 0),
@@ -3101,6 +3208,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
@@ -3130,6 +3238,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(0,8)));
@@ -3163,6 +3272,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(0,8)));
@@ -3196,6 +3306,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3233,6 +3344,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rd==0) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3269,6 +3381,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3303,6 +3416,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
         auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
            tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
@@ -3334,6 +3448,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, 2);
         auto returnValue = std::make_tuple(CONT);
         
@@ -3361,6 +3476,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3397,6 +3513,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3432,6 +3549,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, 3);
         auto returnValue = std::make_tuple(CONT);
         
@@ -3459,6 +3577,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         if(rs2>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3489,6 +3608,7 @@ private:
         pc=pc+ 2;
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
+        this->gen_set_tval(tu, instr);
         this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = std::make_tuple(CONT);
         
@@ -3625,10 +3745,17 @@ template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsi
 template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
 }
 
+template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, uint64_t new_tval) {
+    tu(fmt::format("tval = {};", new_tval));
+}
+template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, value new_tval) {
+    tu(fmt::format("tval = {};", new_tval.str));
+}
+
 template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu("trap_entry:");
     this->gen_sync(tu, POST_SYNC, -1);    
-    tu("enter_trap(core_ptr, *trap_state, *pc, 0);");
+    tu("enter_trap(core_ptr, *trap_state, *pc, tval);");
     tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(),32));
     tu("return *next_pc;");
 }

From 7a199e122d7f15ca95c8c2d11a9c8bba72228754 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 09:42:12 +0200
Subject: [PATCH 021/100] integrates new tval changes into asmjit

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |   8 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 137 +++++++++++++++++---
 2 files changed, 123 insertions(+), 22 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 6441884..eeb4fe5 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -96,6 +96,7 @@ protected:
     using super::gen_leave;
     using super::gen_operation;
     using super::gen_sync;
+    using super::gen_set_tval;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -163,6 +164,7 @@ private:
         cc.comment(fmt::format("${instr.name}_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, ${idx});
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+${instr.length/8};
         mov(cc, jh.next_pc, pc.val);
 
@@ -300,9 +302,9 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
-
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
+    jh.tval = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -320,15 +322,13 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     x86::Gp current_pc = get_reg_for_Gp(cc, traits::PC);
     mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
-    x86::Gp instr = cc.newInt32("instr");
-    mov(cc, instr, 0); // FIXME:this is not correct, should be instrId of trapping instr
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
     cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, instr);
+    call_enter_trap->setArg(3, jh.tval);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index d2048ed..810da11 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -96,6 +96,7 @@ protected:
     using super::gen_leave;
     using super::gen_operation;
     using super::gen_sync;
+    using super::gen_set_tval;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -338,6 +339,7 @@ private:
         cc.comment(fmt::format("LUI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 0);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -384,6 +386,7 @@ private:
         cc.comment(fmt::format("AUIPC_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 1);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -430,6 +433,7 @@ private:
         cc.comment(fmt::format("JAL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 2);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -440,7 +444,9 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+            auto new_pc = (uint32_t)(PC+(int32_t)sext<21>(imm));
+            if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                gen_set_tval(jh, new_pc);
                 gen_raise(jh, 0, 0);
             }
             else{
@@ -448,7 +454,7 @@ private:
                     mov(cc, get_ptr_for(jh, traits::X0+ rd),
                           (uint32_t)(PC+4));
                 }
-                auto PC_val_v = (uint32_t)(PC+(int32_t)sext<21>(imm));
+                auto PC_val_v = new_pc;
                 mov(cc, jh.next_pc, PC_val_v);
                 mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
             }
@@ -485,6 +491,7 @@ private:
         cc.comment(fmt::format("JALR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 3);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -506,6 +513,7 @@ private:
             auto label_else = cc.newLabel();
             cc.je(label_else);
             {
+                gen_set_tval(jh, new_pc);
                 gen_raise(jh, 0, 0);
             }
             cc.jmp(label_merge);
@@ -553,6 +561,7 @@ private:
         cc.comment(fmt::format("BEQ_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 4);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -568,11 +577,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -611,6 +622,7 @@ private:
         cc.comment(fmt::format("BNE_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 5);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -626,11 +638,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -669,6 +683,7 @@ private:
         cc.comment(fmt::format("BLT_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 6);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -686,11 +701,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -729,6 +746,7 @@ private:
         cc.comment(fmt::format("BGE_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 7);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -746,11 +764,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -789,6 +809,7 @@ private:
         cc.comment(fmt::format("BLTU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 8);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -804,11 +825,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -847,6 +870,7 @@ private:
         cc.comment(fmt::format("BGEU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 9);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -862,11 +886,13 @@ private:
             ,0);
             cc.je(label_merge);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){
+                    gen_set_tval(jh, new_pc);
                     gen_raise(jh, 0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
                 }
@@ -905,6 +931,7 @@ private:
         cc.comment(fmt::format("LB_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 10);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -958,6 +985,7 @@ private:
         cc.comment(fmt::format("LH_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 11);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1011,6 +1039,7 @@ private:
         cc.comment(fmt::format("LW_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 12);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1064,6 +1093,7 @@ private:
         cc.comment(fmt::format("LBU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 13);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1116,6 +1146,7 @@ private:
         cc.comment(fmt::format("LHU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 14);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1168,6 +1199,7 @@ private:
         cc.comment(fmt::format("SB_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 15);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1216,6 +1248,7 @@ private:
         cc.comment(fmt::format("SH_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 16);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1264,6 +1297,7 @@ private:
         cc.comment(fmt::format("SW_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 17);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1312,6 +1346,7 @@ private:
         cc.comment(fmt::format("ADDI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 18);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1361,6 +1396,7 @@ private:
         cc.comment(fmt::format("SLTI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 19);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1423,6 +1459,7 @@ private:
         cc.comment(fmt::format("SLTIU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 20);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1484,6 +1521,7 @@ private:
         cc.comment(fmt::format("XORI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 21);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1532,6 +1570,7 @@ private:
         cc.comment(fmt::format("ORI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 22);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1580,6 +1619,7 @@ private:
         cc.comment(fmt::format("ANDI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 23);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1628,6 +1668,7 @@ private:
         cc.comment(fmt::format("SLLI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 24);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1676,6 +1717,7 @@ private:
         cc.comment(fmt::format("SRLI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 25);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1724,6 +1766,7 @@ private:
         cc.comment(fmt::format("SRAI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 26);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1774,6 +1817,7 @@ private:
         cc.comment(fmt::format("ADD_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 27);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1823,6 +1867,7 @@ private:
         cc.comment(fmt::format("SUB_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 28);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1872,6 +1917,7 @@ private:
         cc.comment(fmt::format("SLL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 29);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1921,6 +1967,7 @@ private:
         cc.comment(fmt::format("SLT_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 30);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -1984,6 +2031,7 @@ private:
         cc.comment(fmt::format("SLTU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 31);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2045,6 +2093,7 @@ private:
         cc.comment(fmt::format("XOR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 32);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2093,6 +2142,7 @@ private:
         cc.comment(fmt::format("SRL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 33);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2142,6 +2192,7 @@ private:
         cc.comment(fmt::format("SRA_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 34);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2193,6 +2244,7 @@ private:
         cc.comment(fmt::format("OR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 35);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2241,6 +2293,7 @@ private:
         cc.comment(fmt::format("AND_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 36);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2291,6 +2344,7 @@ private:
         cc.comment(fmt::format("FENCE_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 37);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2326,6 +2380,7 @@ private:
         cc.comment(fmt::format("ECALL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 38);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2361,6 +2416,7 @@ private:
         cc.comment(fmt::format("EBREAK_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 39);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2396,6 +2452,7 @@ private:
         cc.comment(fmt::format("MRET_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 40);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2431,6 +2488,7 @@ private:
         cc.comment(fmt::format("WFI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 41);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2470,6 +2528,7 @@ private:
         cc.comment(fmt::format("CSRRW_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 42);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2523,6 +2582,7 @@ private:
         cc.comment(fmt::format("CSRRS_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 43);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2576,6 +2636,7 @@ private:
         cc.comment(fmt::format("CSRRC_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 44);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2629,6 +2690,7 @@ private:
         cc.comment(fmt::format("CSRRWI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 45);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2678,6 +2740,7 @@ private:
         cc.comment(fmt::format("CSRRSI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 46);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2730,6 +2793,7 @@ private:
         cc.comment(fmt::format("CSRRCI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 47);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2782,6 +2846,7 @@ private:
         cc.comment(fmt::format("FENCE_I_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 48);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2821,6 +2886,7 @@ private:
         cc.comment(fmt::format("MUL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 49);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2873,6 +2939,7 @@ private:
         cc.comment(fmt::format("MULH_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 50);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2926,6 +2993,7 @@ private:
         cc.comment(fmt::format("MULHSU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 51);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -2978,6 +3046,7 @@ private:
         cc.comment(fmt::format("MULHU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 52);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3029,6 +3098,7 @@ private:
         cc.comment(fmt::format("DIV_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 53);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3113,6 +3183,7 @@ private:
         cc.comment(fmt::format("DIVU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 54);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3177,6 +3248,7 @@ private:
         cc.comment(fmt::format("REM_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 55);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3265,6 +3337,7 @@ private:
         cc.comment(fmt::format("REMU_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 56);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+4;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3328,6 +3401,7 @@ private:
         cc.comment(fmt::format("C__ADDI4SPN_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 57);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3375,6 +3449,7 @@ private:
         cc.comment(fmt::format("C__LW_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 58);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3420,6 +3495,7 @@ private:
         cc.comment(fmt::format("C__SW_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 59);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3462,6 +3538,7 @@ private:
         cc.comment(fmt::format("C__ADDI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 60);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3508,6 +3585,7 @@ private:
         cc.comment(fmt::format("C__NOP_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 61);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3544,6 +3622,7 @@ private:
         cc.comment(fmt::format("C__JAL_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 62);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3586,6 +3665,7 @@ private:
         cc.comment(fmt::format("C__LI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 63);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3632,6 +3712,7 @@ private:
         cc.comment(fmt::format("C__LUI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 64);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3675,6 +3756,7 @@ private:
         cc.comment(fmt::format("C__ADDI16SP_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 65);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3719,6 +3801,7 @@ private:
         cc.comment(fmt::format("__reserved_clui_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 66);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3757,6 +3840,7 @@ private:
         cc.comment(fmt::format("C__SRLI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 67);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3797,6 +3881,7 @@ private:
         cc.comment(fmt::format("C__SRAI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 68);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3850,6 +3935,7 @@ private:
         cc.comment(fmt::format("C__ANDI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 69);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3891,6 +3977,7 @@ private:
         cc.comment(fmt::format("C__SUB_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 70);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3932,6 +4019,7 @@ private:
         cc.comment(fmt::format("C__XOR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 71);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -3972,6 +4060,7 @@ private:
         cc.comment(fmt::format("C__OR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 72);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4012,6 +4101,7 @@ private:
         cc.comment(fmt::format("C__AND_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 73);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4051,6 +4141,7 @@ private:
         cc.comment(fmt::format("C__J_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 74);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4091,6 +4182,7 @@ private:
         cc.comment(fmt::format("C__BEQZ_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 75);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4138,6 +4230,7 @@ private:
         cc.comment(fmt::format("C__BNEZ_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 76);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4185,6 +4278,7 @@ private:
         cc.comment(fmt::format("C__SLLI_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 77);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4232,6 +4326,7 @@ private:
         cc.comment(fmt::format("C__LWSP_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 78);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4281,6 +4376,7 @@ private:
         cc.comment(fmt::format("C__MV_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 79);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4326,6 +4422,7 @@ private:
         cc.comment(fmt::format("C__JR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 80);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4370,6 +4467,7 @@ private:
         cc.comment(fmt::format("__reserved_cmv_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 81);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4408,6 +4506,7 @@ private:
         cc.comment(fmt::format("C__ADD_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 82);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4455,6 +4554,7 @@ private:
         cc.comment(fmt::format("C__JALR_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 83);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4502,6 +4602,7 @@ private:
         cc.comment(fmt::format("C__EBREAK_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 84);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4540,6 +4641,7 @@ private:
         cc.comment(fmt::format("C__SWSP_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 85);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4584,6 +4686,7 @@ private:
         cc.comment(fmt::format("DII_{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, 86);
         mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc+2;
         mov(cc, jh.next_pc, pc.val);
 
@@ -4722,9 +4825,9 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
-
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
+    jh.tval = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -4742,15 +4845,13 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     x86::Gp current_pc = get_reg_for_Gp(cc, traits::PC);
     mov(cc, current_pc, get_ptr_for(jh, traits::PC));
 
-    x86::Gp instr = cc.newInt32("instr");
-    mov(cc, instr, 0); // FIXME:this is not correct, should be instrId of trapping instr
     cc.comment("//enter trap call;");
     InvokeNode* call_enter_trap;
     cc.invoke(&call_enter_trap, &enter_trap, FuncSignature::build<uint64_t, void*, uint64_t, uint64_t, uint64_t>());
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, instr);
+    call_enter_trap->setArg(3, jh.tval);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));

From ac1a26a10c9233e6478b0a7cbe57a80621b3dda3 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 14:17:02 +0200
Subject: [PATCH 022/100] integrates new tval changes into llvm

---
 gen_input/templates/llvm/CORENAME.cpp.gtl |  14 +-
 src/vm/llvm/vm_tgc5c.cpp                  | 165 ++++++++++++++++++----
 2 files changed, 152 insertions(+), 27 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 32ca308..e198e6e 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -102,6 +102,8 @@ protected:
     void gen_raise_trap(uint16_t trap_id, uint16_t cause);
     void gen_leave_trap(unsigned lvl);
     void gen_wait(unsigned type);
+    void set_tval(uint64_t new_tval);
+    void set_tval(Value* new_tval);
     void gen_trap_behavior(BasicBlock *) override;
     void gen_instr_epilogue(BasicBlock *bb);
 
@@ -168,6 +170,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ ${instr.length/8};
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         <%instr.behavior.eachLine{%>${it}
@@ -326,6 +329,15 @@ void vm_impl<ARCH>::gen_wait(unsigned type) {
     this->builder.CreateCall(this->mod->getFunction("wait"), args);
 }
 
+template <typename ARCH>
+inline void vm_impl<ARCH>::set_tval(uint64_t tval) {
+    auto tmp_tval = this->gen_const(64, tval);
+    this->set_tval(tmp_tval);
+}
+template <typename ARCH>
+inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
+    this->builder.CreateStore(new_tval, this->tval);
+}
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
@@ -334,7 +346,7 @@ void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);
     std::vector<Value *> args{this->core_ptr, this->adj_to64(trap_state_val),
-                              this->adj_to64(this->builder.CreateLoad(this->get_typeptr(traits::PC), get_reg_ptr(traits::PC), false))};
+                              this->adj_to64(this->builder.CreateLoad(this->builder.getInt64Ty(),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 7411353..9ab029c 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -102,6 +102,8 @@ protected:
     void gen_raise_trap(uint16_t trap_id, uint16_t cause);
     void gen_leave_trap(unsigned lvl);
     void gen_wait(unsigned type);
+    void set_tval(uint64_t new_tval);
+    void set_tval(Value* new_tval);
     void gen_trap_behavior(BasicBlock *) override;
     void gen_instr_epilogue(BasicBlock *bb);
 
@@ -349,6 +351,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -392,6 +395,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -435,13 +439,16 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+            auto new_pc =(uint32_t)(PC+(int32_t)sext<21>(imm));
+            if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+            this->gen_raise_trap(0, 0);
             }
             else{
                 if(rd!=0) {
@@ -449,7 +456,7 @@ private:
                          this->gen_const(32,(uint32_t)(PC+4)),
                          get_reg_ptr(rd + traits::X0), false);
                 }
-                auto PC_val_v = (uint32_t)(PC+(int32_t)sext<21>(imm));
+                auto PC_val_v = new_pc;
                 this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                 this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
             }
@@ -486,20 +493,21 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto addr_mask =this->gen_const(32,(uint32_t)- 2);
+            auto addr_mask =(uint32_t)- 2;
             auto new_pc =this->gen_ext(
                 (this->builder.CreateAnd(
                    (this->builder.CreateAdd(
                       this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
                       this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                    ),
-                   this->gen_ext(addr_mask, 64,false))
+                   this->gen_ext(this->gen_const(32,addr_mask), 64,false))
                 ),
                 32, true);
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -511,6 +519,7 @@ private:
             , 1), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
+                this->set_tval(new_pc);
                 this->gen_raise_trap(0, 0);
             }
             this->builder.CreateBr(bb_merge);
@@ -560,6 +569,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -574,10 +584,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -617,6 +629,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -631,10 +644,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -674,6 +689,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -692,10 +708,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -735,6 +753,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -753,10 +772,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -796,6 +817,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -810,10 +832,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -853,6 +877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -867,10 +892,12 @@ private:
             , 1), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
-                if(imm%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->gen_raise_trap(0, 0);
+                auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
+                if(new_pc%static_cast<uint32_t>(traits::INSTR_ALIGNMENT)){ this->set_tval(new_pc);
+                this->gen_raise_trap(0, 0);
                 }
                 else{
-                    auto PC_val_v = (uint32_t)(PC+(int16_t)sext<13>(imm));
+                    auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
                     this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
@@ -910,6 +937,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -965,6 +993,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1020,6 +1049,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1075,6 +1105,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1128,6 +1159,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1181,6 +1213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1231,6 +1264,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1281,6 +1315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1331,6 +1366,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1380,6 +1416,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1431,6 +1468,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1481,6 +1519,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1528,6 +1567,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1575,6 +1615,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1622,6 +1663,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1669,6 +1711,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1716,6 +1759,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1765,6 +1809,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1814,6 +1859,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1863,6 +1909,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1913,6 +1960,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1965,6 +2013,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2015,6 +2064,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2062,6 +2112,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2112,6 +2163,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2165,6 +2217,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2212,6 +2265,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2261,6 +2315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2287,6 +2342,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 11);
@@ -2311,6 +2367,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
@@ -2335,6 +2392,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_leave_trap(3);
@@ -2359,6 +2417,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_wait(1);
@@ -2394,6 +2453,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2447,6 +2507,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2501,6 +2562,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2555,6 +2617,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2603,6 +2666,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2656,6 +2720,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2709,6 +2774,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2746,6 +2812,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2798,6 +2865,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2853,6 +2921,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2907,6 +2976,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2960,6 +3030,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2979,14 +3050,14 @@ private:
             , 1), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
-                auto MMIN =this->gen_const(32,((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1));
+                auto MMIN =((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
                 this->builder.CreateCondBr(this->gen_ext(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_reg_load(rs1+ traits::X0, 0),
-                      MMIN)
+                      this->gen_const(32,MMIN))
                    ,
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       divisor,
@@ -2996,7 +3067,7 @@ private:
                 this->builder.SetInsertPoint(bb_then);
                 {
                     this->builder.CreateStore(
-                         MMIN,
+                         this->gen_const(32,MMIN),
                          get_reg_ptr(rd + traits::X0), false);
                 }
                 this->builder.CreateBr(bb_merge);
@@ -3057,6 +3128,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3125,6 +3197,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3140,14 +3213,14 @@ private:
             , 1), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
-                auto MMIN =this->gen_const(32,(uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1));
+                auto MMIN =(uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
                 this->builder.CreateCondBr(this->gen_ext(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_reg_load(rs1+ traits::X0, 0),
-                      MMIN)
+                      this->gen_const(32,MMIN))
                    ,
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_ext(
@@ -3226,6 +3299,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3293,6 +3367,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(imm) {
@@ -3340,6 +3415,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3387,6 +3463,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3431,6 +3508,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -3470,6 +3548,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3502,6 +3581,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3541,6 +3621,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3584,6 +3665,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3624,6 +3706,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(nzimm) {
@@ -3661,6 +3744,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3695,6 +3779,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3734,6 +3819,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(shamt){ this->builder.CreateStore(
@@ -3791,6 +3877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3832,6 +3919,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3873,6 +3961,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3912,6 +4001,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3951,6 +4041,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3989,6 +4080,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
@@ -4025,6 +4117,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4072,6 +4165,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4119,6 +4213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -4165,6 +4260,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0) {
@@ -4216,6 +4312,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4258,12 +4355,13 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
-        if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =this->gen_const(32,(uint32_t)- 2);
+        if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
         auto PC_val_v = this->builder.CreateAnd(
            this->gen_reg_load(rs1%static_cast<uint32_t>(traits::RFS)+ traits::X0, 0),
-           addr_mask)
+           this->gen_const(32,addr_mask))
         ;
         this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
         this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
@@ -4292,6 +4390,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 2);
@@ -4326,6 +4425,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4373,20 +4473,21 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto addr_mask =this->gen_const(32,(uint32_t)- 2);
+            auto addr_mask =(uint32_t)- 2;
             auto new_pc =this->gen_reg_load(rs1+ traits::X0, 0);
             this->builder.CreateStore(
                  this->gen_const(32,(uint32_t)(PC+2)),
                  get_reg_ptr(1 + traits::X0), false);
             auto PC_val_v = this->builder.CreateAnd(
                new_pc,
-               addr_mask)
+               this->gen_const(32,addr_mask))
             ;
             this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
             this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
@@ -4412,6 +4513,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
@@ -4446,6 +4548,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -4485,6 +4588,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
+        this->set_tval(PC);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4645,6 +4749,15 @@ void vm_impl<ARCH>::gen_wait(unsigned type) {
     this->builder.CreateCall(this->mod->getFunction("wait"), args);
 }
 
+template <typename ARCH>
+inline void vm_impl<ARCH>::set_tval(uint64_t tval) {
+    auto tmp_tval = this->gen_const(64, tval);
+    this->set_tval(tmp_tval);
+}
+template <typename ARCH>
+inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
+    this->builder.CreateStore(this->gen_ext(new_tval, 64, false), this->tval);
+}   
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
@@ -4653,7 +4766,7 @@ void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);
     std::vector<Value *> args{this->core_ptr, this->adj_to64(trap_state_val),
-                              this->adj_to64(this->builder.CreateLoad(this->get_typeptr(traits::PC), get_reg_ptr(traits::PC), false))};
+                              this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);

From 11a30caae86e8a15e672fb396b75437d8aedaff4 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 15:14:13 +0200
Subject: [PATCH 023/100] integrates generator changes to canPrecompute

---
 src/vm/tcc/vm_tgc5c.cpp | 154 ++++++++++++++++++----------------------
 1 file changed, 70 insertions(+), 84 deletions(-)

diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 6483ec1..a45b74a 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -426,21 +426,19 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int32_t)sext<21>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int32_t)sext<21>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)(PC+4),32));
         	}
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	else{
+        		if(rd!=0) {
+        		    tu.store(rd + traits::X0,
+        		          tu.constant((uint32_t)(PC+4),32));
+        		}
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         }
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -474,12 +472,12 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
+        	auto addr_mask = (uint32_t)- 2;
         	auto new_pc = tu.assignment(tu.ext((tu.bitwise_and(
         	   (tu.add(
         	      tu.load(rs1+ traits::X0, 0),
         	      tu.constant((int16_t)sext<12>(imm),16))),
-        	   addr_mask)),32,false),32);
+        	   tu.constant(addr_mask,32))),32,false),32);
         	tu.open_if(tu.urem(
         	   new_pc,
         	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
@@ -530,17 +528,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -578,17 +574,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -626,17 +620,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
         	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -674,17 +666,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
         	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -722,17 +712,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -770,17 +758,15 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
         	   tu.load(rs1+ traits::X0, 0),
         	   tu.load(rs2+ traits::X0, 0)));
-        	auto new_pc = tu.assignment(tu.constant((uint32_t)(PC+(int16_t)sext<13>(imm)),32),32);
-        	tu.open_if(tu.urem(
-        	   new_pc,
-        	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
-        	this->gen_set_tval(tu, new_pc);
+        	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
+        	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
-        	tu.open_else();
-        	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
-        	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
-        	tu.close_scope();
+        	}
+        	else{
+        		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
+        		tu.store(traits::NEXT_PC, PC_val_v);
+        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -2456,16 +2442,16 @@ private:
         	if(rd!=0){ tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   divisor,
         	   tu.constant(0,8)));
-        	auto MMIN = tu.assignment(tu.constant(((uint32_t)1)<<(static_cast<uint32_t>(traits:: XLEN)-1),32),32);
+        	auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      tu.load(rs1+ traits::X0, 0),
-        	      MMIN),
+        	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      divisor,
         	      tu.constant(- 1,8))));
         	tu.store(rd + traits::X0,
-        	      MMIN);
+        	      tu.constant(MMIN,32));
         	tu.open_else();
         	tu.store(rd + traits::X0,
         	      tu.ext((tu.sdiv(
@@ -2561,11 +2547,11 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs2+ traits::X0, 0),
         	   tu.constant(0,8)));
-        	auto MMIN = tu.assignment(tu.constant((uint32_t)1<<(static_cast<uint32_t>(traits:: XLEN)-1),32),32);
+        	auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      tu.load(rs1+ traits::X0, 0),
-        	      MMIN),
+        	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      tu.ext(tu.load(rs2+ traits::X0, 0),32,true),
         	      tu.constant(- 1,8))));
@@ -3417,10 +3403,10 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
+        if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = (uint32_t)- 2;
         auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
            tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
-           addr_mask),32);
+           tu.constant(addr_mask,32)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }
@@ -3518,13 +3504,13 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto addr_mask = tu.assignment(tu.constant((uint32_t)- 2,32),32);
+        	auto addr_mask = (uint32_t)- 2;
         	auto new_pc = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
         	tu.store(1 + traits::X0,
         	      tu.constant((uint32_t)(PC+2),32));
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
         	   new_pc,
-        	   addr_mask),32);
+        	   tu.constant(addr_mask,32)),32);
         	tu.store(traits::NEXT_PC, PC_val_v);
         	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
         }

From 6dc17857da3f8d585e47fa1237df7838bfc40431 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 15:36:08 +0200
Subject: [PATCH 024/100] updates template

---
 gen_input/templates/llvm/CORENAME.cpp.gtl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index e198e6e..d5cb4f4 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -336,7 +336,7 @@ inline void vm_impl<ARCH>::set_tval(uint64_t tval) {
 }
 template <typename ARCH>
 inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
-    this->builder.CreateStore(new_tval, this->tval);
+    this->builder.CreateStore(this->gen_ext(new_tval, 64, false), this->tval);
 }
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
@@ -346,7 +346,7 @@ void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);
     std::vector<Value *> args{this->core_ptr, this->adj_to64(trap_state_val),
-                              this->adj_to64(this->builder.CreateLoad(this->builder.getInt64Ty(),this->tval))};
+                              this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);

From fa82a508244b5611b839a77f03c02abf7c044801 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 17:24:17 +0200
Subject: [PATCH 025/100] fixes typo in templates

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 6 +++---
 gen_input/templates/llvm/CORENAME.cpp.gtl   | 4 ++--
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index eeb4fe5..76a3d45 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -181,9 +181,9 @@ private:
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    continuation_e illegal_intruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
+    continuation_e illegal_instruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
         x86::Compiler& cc = jh.cc;
-        cc.comment(fmt::format("illegal_intruction{:#x}:",pc.val).c_str());
+        cc.comment(fmt::format("illegal_instruction{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, instr_descr.size());
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_instr_prologue(jh);
@@ -275,7 +275,7 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) 
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     return (this->*f)(pc, instr, jh);
 }
 template <typename ARCH>
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index d5cb4f4..447c720 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -184,7 +184,7 @@ private:
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    std::tuple<continuation_e, BasicBlock *> illegal_intruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+    std::tuple<continuation_e, BasicBlock *> illegal_instruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
 		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
@@ -296,7 +296,7 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) {
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     }
     return (this->*f)(pc, instr, this_block);
 }
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 40db6d4..78a45ed 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -185,7 +185,7 @@ private:
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    compile_ret_t illegal_intruction(virt_addr_t &pc, code_word_t instr, tu_builder& tu) {
+    compile_ret_t illegal_instruction(virt_addr_t &pc, code_word_t instr, tu_builder& tu) {
         vm_impl::gen_sync(tu, iss::PRE_SYNC, instr_descr.size());
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_raise_trap(tu, 0, 2);     // illegal instruction trap
@@ -290,7 +290,7 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) {
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     }
     return (this->*f)(pc, instr, tu);
 }

From 1a4465a371504e47007e1df4f568ff91ed2820fc Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 19:59:01 +0200
Subject: [PATCH 026/100] changes template: adds correct illegal instruction,
 reorders gen_sync to allow correct instr id eve when trapping, adds newly
 generated vm

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |  20 +-
 src/vm/asmjit/vm_tgc5c.cpp                  | 198 +++++++++++---------
 2 files changed, 123 insertions(+), 95 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 76a3d45..90446be 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -173,8 +173,8 @@ private:
         /*generate behavior*/
         <%instr.behavior.eachLine{%>${it}
         <%}%>
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, ${idx});
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     <%}%>
@@ -183,13 +183,27 @@ private:
      ****************************************************************************/
     continuation_e illegal_instruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
         x86::Compiler& cc = jh.cc;
+        if(this->disass_enabled){          
+            auto mnemonic = std::string("illegal_instruction");
+            InvokeNode* call_print_disass;
+            char* mnemonic_ptr = strdup(mnemonic.c_str());
+            jh.disass_collection.push_back(mnemonic_ptr);
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
+            call_print_disass->setArg(0, jh.arch_if_ptr);
+            call_print_disass->setArg(1, pc.val);
+            call_print_disass->setArg(2, mnemonic_ptr);
+        }
         cc.comment(fmt::format("illegal_instruction{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, instr_descr.size());
+        mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        mov(cc, jh.next_pc, pc.val);
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
-        gen_instr_epilogue(jh);
+        gen_raise(jh, 0, 2);
         gen_sync(jh, POST_SYNC, instr_descr.size());
+        gen_instr_epilogue(jh);
         return BRANCH;
     }
      
@@ -283,7 +297,6 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_prologue");
-    cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
     x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
@@ -299,6 +312,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
+    cc.inc(get_ptr_for(jh, traits::ICOUNT));
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 810da11..e4f351e 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -357,8 +357,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 0);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -404,8 +404,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 1);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -461,8 +461,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 2);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -531,8 +531,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 3);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -592,8 +592,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 4);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -653,8 +653,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 5);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -716,8 +716,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 6);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -779,8 +779,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 7);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -840,8 +840,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 8);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -901,8 +901,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 9);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -955,8 +955,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 10);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1009,8 +1009,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 11);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1063,8 +1063,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 12);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1116,8 +1116,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 13);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1169,8 +1169,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 14);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1218,8 +1218,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 15);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1267,8 +1267,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 16);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1316,8 +1316,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 17);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1366,8 +1366,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 18);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1429,8 +1429,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 19);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1491,8 +1491,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 20);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1540,8 +1540,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 21);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1589,8 +1589,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 22);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1638,8 +1638,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 23);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1687,8 +1687,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 24);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1736,8 +1736,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 25);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1787,8 +1787,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 26);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1837,8 +1837,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 27);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1887,8 +1887,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 28);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -1937,8 +1937,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 29);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2001,8 +2001,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 30);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2063,8 +2063,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 31);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2112,8 +2112,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 32);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2162,8 +2162,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 33);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2214,8 +2214,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 34);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2263,8 +2263,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 35);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2312,8 +2312,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 36);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2354,8 +2354,8 @@ private:
         gen_write_mem(jh, traits::FENCE, static_cast<uint32_t>(traits::fence), (uint8_t)pred<<4|succ, 4);
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 37);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2390,8 +2390,8 @@ private:
         gen_raise(jh, 0, 11);
         auto returnValue = TRAP;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 38);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2426,8 +2426,8 @@ private:
         gen_raise(jh, 0, 3);
         auto returnValue = TRAP;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 39);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2462,8 +2462,8 @@ private:
         gen_leave(jh, 3);
         auto returnValue = TRAP;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 40);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2498,8 +2498,8 @@ private:
         gen_wait(jh, 1);
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 41);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2552,8 +2552,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 42);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2606,8 +2606,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 43);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2660,8 +2660,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 44);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2710,8 +2710,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 45);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2763,8 +2763,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 46);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2816,8 +2816,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 47);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2856,8 +2856,8 @@ private:
         gen_write_mem(jh, traits::FENCE, static_cast<uint32_t>(traits::fencei), imm, 4);
         auto returnValue = FLUSH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 48);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2909,8 +2909,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 49);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -2963,8 +2963,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 50);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3016,8 +3016,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 51);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3068,8 +3068,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 52);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3153,8 +3153,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 53);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3218,8 +3218,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 54);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3307,8 +3307,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 55);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3372,8 +3372,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 56);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3419,8 +3419,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 57);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3465,8 +3465,8 @@ private:
                       gen_read_mem(jh, traits::MEM, offs, 4), 32, false), 32, true));
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 58);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3509,8 +3509,8 @@ private:
             load_reg_from_mem(jh, traits::X0 + rs2+8), 32, false), 4);
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 59);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3558,8 +3558,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 60);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3594,8 +3594,8 @@ private:
         /*generate behavior*/
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 61);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3636,8 +3636,8 @@ private:
         mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 62);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3683,8 +3683,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 63);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3728,8 +3728,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 64);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3774,8 +3774,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 65);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3811,8 +3811,8 @@ private:
         gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 66);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3852,8 +3852,8 @@ private:
               );
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 67);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3906,8 +3906,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 68);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3948,8 +3948,8 @@ private:
                   ), 32, true));
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 69);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -3990,8 +3990,8 @@ private:
                   ), 32, true));
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 70);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4031,8 +4031,8 @@ private:
               );
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 71);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4072,8 +4072,8 @@ private:
               );
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 72);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4113,8 +4113,8 @@ private:
               );
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 73);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4153,8 +4153,8 @@ private:
         mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 74);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4201,8 +4201,8 @@ private:
         cc.bind(label_merge);
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 75);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4249,8 +4249,8 @@ private:
         cc.bind(label_merge);
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 76);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4297,8 +4297,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 77);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4347,8 +4347,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 78);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4394,8 +4394,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 79);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4441,8 +4441,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 80);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4477,8 +4477,8 @@ private:
         gen_raise(jh, 0, 2);
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 81);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4526,8 +4526,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 82);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4576,8 +4576,8 @@ private:
         }
         auto returnValue = BRANCH;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 83);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4612,8 +4612,8 @@ private:
         gen_raise(jh, 0, 3);
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 84);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4660,8 +4660,8 @@ private:
         }
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 85);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
@@ -4696,23 +4696,37 @@ private:
         gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         auto returnValue = CONT;
         
-        gen_instr_epilogue(jh);
         gen_sync(jh, POST_SYNC, 86);
+        gen_instr_epilogue(jh);
     	return returnValue;        
     }
     
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    continuation_e illegal_intruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
+    continuation_e illegal_instruction(virt_addr_t &pc, code_word_t instr, jit_holder& jh ) {
         x86::Compiler& cc = jh.cc;
-        cc.comment(fmt::format("illegal_intruction{:#x}:",pc.val).c_str());
+        if(this->disass_enabled){          
+            auto mnemonic = std::string("illegal_instruction");
+            InvokeNode* call_print_disass;
+            char* mnemonic_ptr = strdup(mnemonic.c_str());
+            jh.disass_collection.push_back(mnemonic_ptr);
+            jh.cc.invoke(&call_print_disass, &print_disass, FuncSignature::build<void, void *, uint64_t, char *>());
+            call_print_disass->setArg(0, jh.arch_if_ptr);
+            call_print_disass->setArg(1, pc.val);
+            call_print_disass->setArg(2, mnemonic_ptr);
+        }
+        cc.comment(fmt::format("illegal_instruction{:#x}:",pc.val).c_str());
         gen_sync(jh, PRE_SYNC, instr_descr.size());
+        mov(cc, jh.pc, pc.val);
+        gen_set_tval(jh, instr);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        mov(cc, jh.next_pc, pc.val);
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
-        gen_instr_epilogue(jh);
+        gen_raise(jh, 0, 2);
         gen_sync(jh, POST_SYNC, instr_descr.size());
+        gen_instr_epilogue(jh);
         return BRANCH;
     }
      
@@ -4798,7 +4812,7 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) 
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     return (this->*f)(pc, instr, jh);
 }
 template <typename ARCH>
@@ -4806,7 +4820,6 @@ void vm_impl<ARCH>::gen_instr_prologue(jit_holder& jh) {
     auto& cc = jh.cc;
 
     cc.comment("//gen_instr_prologue");
-    cc.inc(get_ptr_for(jh, traits::ICOUNT));
 
     x86_reg_t current_trap_state = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
@@ -4822,6 +4835,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
+    cc.inc(get_ptr_for(jh, traits::ICOUNT));
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){

From 244bf6d2f25223ebef37ef8d09df77ce110e6cbf Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 20:25:49 +0200
Subject: [PATCH 027/100] corrects gen_sync before trap check, improves
 illegal_instruction

---
 gen_input/templates/tcc/CORENAME.cpp.gtl |   7 +-
 src/vm/tcc/vm_tgc5c.cpp                  | 183 ++++++++++++-----------
 2 files changed, 100 insertions(+), 90 deletions(-)

diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 78a45ed..3480e56 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -177,8 +177,8 @@ private:
         <%instr.behavior.eachLine{%>${it}
         <%}%>
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,${idx});
+        gen_trap_check(tu);        
         return returnValue;
     }
     <%}%>
@@ -187,8 +187,13 @@ private:
      ****************************************************************************/
     compile_ret_t illegal_instruction(virt_addr_t &pc, code_word_t instr, tu_builder& tu) {
         vm_impl::gen_sync(tu, iss::PRE_SYNC, instr_descr.size());
+        if(this->disass_enabled){
+            /* generate console output when executing the command */
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
+        }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
         return BRANCH;
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index a45b74a..1c23d54 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -362,8 +362,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,0);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -398,8 +398,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,1);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -443,8 +443,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,2);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -496,8 +496,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,3);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -542,8 +542,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,4);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -588,8 +588,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,5);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -634,8 +634,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,6);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -680,8 +680,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,7);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -726,8 +726,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,8);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -772,8 +772,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,9);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -813,8 +813,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,10);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -854,8 +854,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,11);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -895,8 +895,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,12);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -936,8 +936,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,13);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -977,8 +977,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,14);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1014,8 +1014,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,15);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1051,8 +1051,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,16);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1088,8 +1088,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,17);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1127,8 +1127,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,18);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1166,8 +1166,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,19);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1205,8 +1205,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,20);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1244,8 +1244,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,21);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1283,8 +1283,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,22);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1322,8 +1322,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,23);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1361,8 +1361,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,24);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1400,8 +1400,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,25);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1439,8 +1439,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,26);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1478,8 +1478,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,27);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1517,8 +1517,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,28);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1558,8 +1558,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,29);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1597,8 +1597,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,30);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1636,8 +1636,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,31);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1675,8 +1675,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,32);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1716,8 +1716,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,33);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1757,8 +1757,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,34);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1796,8 +1796,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,35);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1835,8 +1835,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,36);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1866,8 +1866,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,37);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1889,8 +1889,8 @@ private:
         auto returnValue = std::make_tuple(TRAP);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,38);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1912,8 +1912,8 @@ private:
         auto returnValue = std::make_tuple(TRAP);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,39);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1935,8 +1935,8 @@ private:
         auto returnValue = std::make_tuple(TRAP);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,40);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -1958,8 +1958,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,41);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2000,8 +2000,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,42);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2044,8 +2044,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,43);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2088,8 +2088,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,44);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2127,8 +2127,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,45);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2170,8 +2170,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,46);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2213,8 +2213,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,47);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2242,8 +2242,8 @@ private:
         auto returnValue = std::make_tuple(FLUSH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,48);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2282,8 +2282,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,49);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2324,8 +2324,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,50);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2366,8 +2366,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,51);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2408,8 +2408,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,52);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2467,8 +2467,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,53);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2515,8 +2515,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,54);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2577,8 +2577,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,55);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2625,8 +2625,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,56);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2661,8 +2661,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,57);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2694,8 +2694,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,58);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2726,8 +2726,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,59);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2764,8 +2764,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,60);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2787,8 +2787,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,61);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2818,8 +2818,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,62);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2854,8 +2854,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,63);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2888,8 +2888,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,64);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2923,8 +2923,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,65);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2947,8 +2947,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,66);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -2978,8 +2978,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,67);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3017,8 +3017,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,68);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3048,8 +3048,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,69);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3079,8 +3079,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,70);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3110,8 +3110,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,71);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3141,8 +3141,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,72);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3172,8 +3172,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,73);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3201,8 +3201,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,74);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3235,8 +3235,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,75);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3269,8 +3269,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,76);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3307,8 +3307,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,77);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3344,8 +3344,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,78);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3380,8 +3380,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,79);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3416,8 +3416,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,80);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3439,8 +3439,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,81);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3477,8 +3477,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,82);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3517,8 +3517,8 @@ private:
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,83);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3540,8 +3540,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,84);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3576,8 +3576,8 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,85);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
@@ -3599,18 +3599,23 @@ private:
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
-        gen_trap_check(tu);        
         vm_base<ARCH>::gen_sync(tu, POST_SYNC,86);
+        gen_trap_check(tu);        
         return returnValue;
     }
     
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    compile_ret_t illegal_intruction(virt_addr_t &pc, code_word_t instr, tu_builder& tu) {
+    compile_ret_t illegal_instruction(virt_addr_t &pc, code_word_t instr, tu_builder& tu) {
         vm_impl::gen_sync(tu, iss::PRE_SYNC, instr_descr.size());
+        if(this->disass_enabled){
+            /* generate console output when executing the command */
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
+        }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
         gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
         return BRANCH;
@@ -3712,7 +3717,7 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) {
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     }
     return (this->*f)(pc, instr, tu);
 }

From b24965d3212a451d433268e74af375a8ff72e11f Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 20:52:01 +0200
Subject: [PATCH 028/100] corrects gen_sync update order, improves illegal
 instruction

---
 gen_input/templates/llvm/CORENAME.cpp.gtl |  15 +-
 src/vm/llvm/vm_tgc5c.cpp                  | 365 +++++++++++-----------
 2 files changed, 199 insertions(+), 181 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 447c720..07601c1 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -170,13 +170,13 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ ${instr.length/8};
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         <%instr.behavior.eachLine{%>${it}
         <%}%>
+        this->gen_sync(POST_SYNC, ${idx});
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, ${idx});
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -185,6 +185,15 @@ private:
      * end opcode definitions
      ****************************************************************************/
     std::tuple<continuation_e, BasicBlock *> illegal_instruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+        if(this->disass_enabled){
+            auto mnemonic = std::string("illegal_instruction");
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
+        }
 		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
@@ -193,6 +202,7 @@ private:
                                      this->gen_const(64U, 1)),
             get_reg_ptr(traits::ICOUNT), true);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
         this->gen_instr_epilogue(this->leave_blk);
@@ -341,7 +351,6 @@ inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
-    this->gen_sync(POST_SYNC, -1); //TODO get right InstrId
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 9ab029c..4313a53 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -351,7 +351,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -367,8 +367,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 0);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 0);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -395,7 +395,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -411,8 +411,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 1);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 1);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -439,7 +439,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -464,8 +464,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 2);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 2);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -493,7 +493,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -540,8 +540,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 3);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 3);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -569,7 +569,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -600,8 +600,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 4);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 4);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -629,7 +629,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -660,8 +660,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 5);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 5);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -689,7 +689,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -724,8 +724,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 6);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 6);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -753,7 +753,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -788,8 +788,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 7);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 7);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -817,7 +817,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -848,8 +848,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 8);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 8);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -877,7 +877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -908,8 +908,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 9);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 9);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -937,7 +937,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -964,8 +964,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 10);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 10);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -993,7 +993,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1020,8 +1020,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 11);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 11);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1049,7 +1049,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1076,8 +1076,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 12);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 12);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1105,7 +1105,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1130,8 +1130,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 13);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 13);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1159,7 +1159,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1184,8 +1184,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 14);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 14);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1213,7 +1213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1235,8 +1235,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 15);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 15);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1264,7 +1264,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1286,8 +1286,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 16);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 16);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1315,7 +1315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1337,8 +1337,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 17);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 17);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1366,7 +1366,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1387,8 +1387,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 18);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 18);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1416,7 +1416,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1439,8 +1439,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 19);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 19);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1468,7 +1468,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1490,8 +1490,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 20);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 20);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1519,7 +1519,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1538,8 +1538,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 21);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 21);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1567,7 +1567,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1586,8 +1586,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 22);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 22);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1615,7 +1615,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1634,8 +1634,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 23);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 23);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1663,7 +1663,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1682,8 +1682,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 24);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 24);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1711,7 +1711,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1730,8 +1730,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 25);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 25);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1759,7 +1759,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1780,8 +1780,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 26);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 26);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1809,7 +1809,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1830,8 +1830,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 27);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 27);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1859,7 +1859,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1880,8 +1880,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 28);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 28);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1909,7 +1909,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1931,8 +1931,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 29);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 29);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1960,7 +1960,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1984,8 +1984,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 30);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 30);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2013,7 +2013,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2035,8 +2035,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 31);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 31);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2064,7 +2064,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2083,8 +2083,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 32);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 32);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2112,7 +2112,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2134,8 +2134,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 33);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 33);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2163,7 +2163,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2188,8 +2188,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 34);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 34);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2217,7 +2217,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2236,8 +2236,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 35);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 35);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2265,7 +2265,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2284,8 +2284,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 36);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 36);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2315,7 +2315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2324,8 +2324,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 37);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 37);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2342,15 +2342,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 11);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 38);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 38);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2367,15 +2367,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 39);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 39);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2392,15 +2392,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_leave_trap(3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 40);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 40);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2417,15 +2417,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_wait(1);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 41);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 41);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2453,7 +2453,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2478,8 +2478,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 42);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 42);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2507,7 +2507,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2533,8 +2533,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 43);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 43);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2562,7 +2562,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2588,8 +2588,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 44);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 44);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2617,7 +2617,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2637,8 +2637,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 45);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 45);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2666,7 +2666,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2691,8 +2691,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 46);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 46);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2720,7 +2720,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2745,8 +2745,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 47);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 47);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2774,7 +2774,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2783,8 +2783,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(FLUSH,nullptr);
         
+        this->gen_sync(POST_SYNC, 48);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 48);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2812,7 +2812,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2836,8 +2836,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 49);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 49);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2865,7 +2865,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2892,8 +2892,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 50);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 50);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2921,7 +2921,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2947,8 +2947,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 51);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 51);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2976,7 +2976,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3001,8 +3001,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 52);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 52);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3030,7 +3030,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3099,8 +3099,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 53);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 53);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3128,7 +3128,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3168,8 +3168,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 54);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 54);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3197,7 +3197,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3270,8 +3270,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 55);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 55);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3299,7 +3299,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3339,8 +3339,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 56);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 56);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3367,7 +3367,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(imm) {
@@ -3386,8 +3386,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 57);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 57);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3415,7 +3415,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3434,8 +3434,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 58);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 58);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3463,7 +3463,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3480,8 +3480,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 59);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 59);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3508,7 +3508,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -3529,8 +3529,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 60);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 60);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3548,14 +3548,14 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 61);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 61);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3581,7 +3581,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3593,8 +3593,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 62);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 62);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3621,7 +3621,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3637,8 +3637,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 63);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 63);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3665,7 +3665,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3679,8 +3679,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 64);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 64);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3706,7 +3706,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(nzimm) {
@@ -3725,8 +3725,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 65);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 65);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3744,15 +3744,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 66);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 66);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3779,7 +3779,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3791,8 +3791,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 67);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 67);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3819,7 +3819,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(shamt){ this->builder.CreateStore(
@@ -3849,8 +3849,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 68);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 68);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3877,7 +3877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3891,8 +3891,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 69);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 69);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3919,7 +3919,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3933,8 +3933,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 70);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 70);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3961,7 +3961,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3973,8 +3973,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 71);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 71);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4001,7 +4001,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -4013,8 +4013,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 72);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 72);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4041,7 +4041,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -4053,8 +4053,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 73);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 73);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4080,7 +4080,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
@@ -4089,8 +4089,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 74);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 74);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4117,7 +4117,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4137,8 +4137,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 75);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 75);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4165,7 +4165,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4185,8 +4185,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 76);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 76);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4213,7 +4213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -4232,8 +4232,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 77);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 77);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4260,7 +4260,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0) {
@@ -4284,8 +4284,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 78);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 78);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4312,7 +4312,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4328,8 +4328,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 79);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 79);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4355,7 +4355,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
@@ -4372,8 +4372,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 80);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 80);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4390,15 +4390,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 2);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 81);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 81);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4425,7 +4425,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4446,8 +4446,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 82);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 82);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4473,7 +4473,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -4495,8 +4495,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 83);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 83);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4513,15 +4513,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 84);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 84);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4548,7 +4548,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -4570,8 +4570,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 85);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 85);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4588,15 +4588,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 86);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 86);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4604,7 +4604,16 @@ private:
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    std::tuple<continuation_e, BasicBlock *> illegal_intruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+    std::tuple<continuation_e, BasicBlock *> illegal_instruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+        if(this->disass_enabled){
+            auto mnemonic = std::string("illegal_instruction");
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
+        }
 		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
@@ -4613,6 +4622,7 @@ private:
                                      this->gen_const(64U, 1)),
             get_reg_ptr(traits::ICOUNT), true);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
         this->gen_instr_epilogue(this->leave_blk);
@@ -4716,7 +4726,7 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) {
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     }
     return (this->*f)(pc, instr, this_block);
 }
@@ -4757,11 +4767,10 @@ inline void vm_impl<ARCH>::set_tval(uint64_t tval) {
 template <typename ARCH>
 inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
     this->builder.CreateStore(this->gen_ext(new_tval, 64, false), this->tval);
-}   
+}
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
-    this->gen_sync(POST_SYNC, -1); //TODO get right InstrId
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);

From 2ec7ea4b41821065b8777a58ad6f768560cec512 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 17 Jul 2024 22:39:12 +0200
Subject: [PATCH 029/100] removes leftover gen_sync in asmjit

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 1 -
 src/vm/asmjit/vm_tgc5c.cpp                  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 90446be..74e5588 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -328,7 +328,6 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
 
     cc.bind(jh.trap_entry);
     this->write_back(jh);
-    this->gen_sync(jh, POST_SYNC, -1);
 
     x86::Gp current_trap_state = get_reg_for_Gp(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index e4f351e..c8816e5 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4851,7 +4851,6 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
 
     cc.bind(jh.trap_entry);
     this->write_back(jh);
-    this->gen_sync(jh, POST_SYNC, -1);
 
     x86::Gp current_trap_state = get_reg_for_Gp(cc, traits::TRAP_STATE);
     mov(cc, current_trap_state, get_ptr_for(jh, traits::TRAP_STATE));

From 8361f887186b5a2a7ebd4bbf8e9ae6e80f3c0e80 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 18 Jul 2024 11:37:53 +0200
Subject: [PATCH 030/100] removes setting of NEXT_PC to max if trap

---
 gen_input/templates/interp/CORENAME.cpp.gtl | 1 -
 src/vm/interp/vm_tgc5c.cpp                  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 2bd17fb..c9624f9 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -106,7 +106,6 @@ protected:
     inline void raise(uint16_t trap_id, uint16_t cause){
         auto trap_val =  0x80ULL << 24 | (cause << 16) | trap_id;
         this->core.reg.trap_state = trap_val;
-        this->template get_reg<uint${addrDataWidth}_t>(traits::NEXT_PC) = std::numeric_limits<uint${addrDataWidth}_t>::max();
     }
 
     inline void leave(unsigned lvl){
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 0656c4b..135ab8c 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -102,7 +102,6 @@ protected:
     inline void raise(uint16_t trap_id, uint16_t cause){
         auto trap_val =  0x80ULL << 24 | (cause << 16) | trap_id;
         this->core.reg.trap_state = trap_val;
-        this->template get_reg<uint32_t>(traits::NEXT_PC) = std::numeric_limits<uint32_t>::max();
     }
 
     inline void leave(unsigned lvl){

From e1b6cab890d2ecd14d4e64047ee7feb5c7d8521b Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 18 Jul 2024 12:02:40 +0200
Subject: [PATCH 031/100] removes setting of NEXT_PC to max when trapping in
 llvm and asmjit, adds default disass to llvm

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |   1 -
 gen_input/templates/llvm/CORENAME.cpp.gtl   |  38 +-
 src/vm/asmjit/vm_tgc5c.cpp                  |   1 -
 src/vm/llvm/vm_tgc5c.cpp                    | 783 +++++++++++++-------
 4 files changed, 545 insertions(+), 278 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 74e5588..eb7cb3d 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -357,7 +357,6 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
-    mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());
 }
 
 } // namespace tgc5c
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 07601c1..0c7f3e0 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -105,6 +105,7 @@ protected:
     void set_tval(uint64_t new_tval);
     void set_tval(Value* new_tval);
     void gen_trap_behavior(BasicBlock *) override;
+    void gen_instr_prologue();
     void gen_instr_epilogue(BasicBlock *bb);
 
     inline Value *gen_reg_load(unsigned i, unsigned level = 0) {
@@ -164,14 +165,22 @@ private:
         <%}%>if(this->disass_enabled){
             /* generate console output when executing the command */<%instr.disass.eachLine{%>
             ${it}<%}%>
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("${instr.name}_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,${idx});
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ ${instr.length/8};
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         <%instr.behavior.eachLine{%>${it}
         <%}%>
@@ -321,15 +330,12 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_raise_trap(uint16_t trap_id, uint16_t cause) {
     auto *TRAP_val = this->gen_const(32, 0x80 << 24 | (cause << 16) | trap_id);
     this->builder.CreateStore(TRAP_val, get_reg_ptr(traits::TRAP_STATE), true);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
 template <typename ARCH>
 void vm_impl<ARCH>::gen_leave_trap(unsigned lvl) {
     std::vector<Value *> args{ this->core_ptr, ConstantInt::get(getContext(), APInt(64, lvl)) };
     this->builder.CreateCall(this->mod->getFunction("leave_trap"), args);
-    auto *PC_val = this->gen_read_mem(traits::CSR, (lvl << 8) + 0x41, traits::XLEN / 8);
-    this->builder.CreateStore(PC_val, get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
@@ -352,14 +358,24 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
-                              get_reg_ptr(traits::LAST_BRANCH), false);
-    std::vector<Value *> args{this->core_ptr, this->adj_to64(trap_state_val),
+    auto *cur_pc_val = this->builder.CreateLoad(this->get_typeptr(traits::PC), get_reg_ptr(traits::PC), true);
+    std::vector<Value *> args{this->core_ptr,
+                                this->adj_to64(trap_state_val),
+                                this->adj_to64(cur_pc_val),
                               this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
+    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);
 }
+template <typename ARCH>
+void vm_impl<ARCH>::gen_instr_prologue() {
+    auto* trap_val =
+        this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::PENDING_TRAP), get_reg_ptr(arch::traits<ARCH>::PENDING_TRAP));
+    this->builder.CreateStore(trap_val, get_reg_ptr(arch::traits<ARCH>::TRAP_STATE), false);
+}
+            
 
 template <typename ARCH>
 void vm_impl<ARCH>::gen_instr_epilogue(BasicBlock *bb) {
@@ -370,6 +386,10 @@ void vm_impl<ARCH>::gen_instr_epilogue(BasicBlock *bb) {
                               ConstantInt::get(getContext(), APInt(v->getType()->getIntegerBitWidth(), 0))),
                           target_bb, this->trap_blk, 1);
     this->builder.SetInsertPoint(target_bb);
+    // update icount
+    auto* icount_val = this->builder.CreateAdd(
+        this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::ICOUNT), get_reg_ptr(arch::traits<ARCH>::ICOUNT)), this->gen_const(64U, 1));
+    this->builder.CreateStore(icount_val, get_reg_ptr(arch::traits<ARCH>::ICOUNT), false);
 }
 
 } // namespace ${coreDef.name.toLowerCase()}
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index c8816e5..da56508 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4880,7 +4880,6 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
-    mov(cc, jh.next_pc, std::numeric_limits<uint32_t>::max());
 }
 
 } // namespace tgc5c
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 4313a53..19bc91b 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -105,6 +105,7 @@ protected:
     void set_tval(uint64_t new_tval);
     void set_tval(Value* new_tval);
     void gen_trap_behavior(BasicBlock *) override;
+    void gen_instr_prologue();
     void gen_instr_epilogue(BasicBlock *bb);
 
     inline Value *gen_reg_load(unsigned i, unsigned level = 0) {
@@ -348,11 +349,13 @@ private:
         }
         bb->setName(fmt::format("LUI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,0);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -392,11 +395,13 @@ private:
         }
         bb->setName(fmt::format("AUIPC_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,1);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -436,11 +441,13 @@ private:
         }
         bb->setName(fmt::format("JAL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,2);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -490,11 +497,13 @@ private:
         }
         bb->setName(fmt::format("JALR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,3);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -566,11 +575,13 @@ private:
         }
         bb->setName(fmt::format("BEQ_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,4);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -626,11 +637,13 @@ private:
         }
         bb->setName(fmt::format("BNE_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,5);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -686,11 +699,13 @@ private:
         }
         bb->setName(fmt::format("BLT_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,6);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -750,11 +765,13 @@ private:
         }
         bb->setName(fmt::format("BGE_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,7);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -814,11 +831,13 @@ private:
         }
         bb->setName(fmt::format("BLTU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,8);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -874,11 +893,13 @@ private:
         }
         bb->setName(fmt::format("BGEU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,9);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -934,11 +955,13 @@ private:
         }
         bb->setName(fmt::format("LB_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,10);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -990,11 +1013,13 @@ private:
         }
         bb->setName(fmt::format("LH_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,11);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1046,11 +1071,13 @@ private:
         }
         bb->setName(fmt::format("LW_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,12);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1102,11 +1129,13 @@ private:
         }
         bb->setName(fmt::format("LBU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,13);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1156,11 +1185,13 @@ private:
         }
         bb->setName(fmt::format("LHU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,14);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1210,11 +1241,13 @@ private:
         }
         bb->setName(fmt::format("SB_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,15);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1261,11 +1294,13 @@ private:
         }
         bb->setName(fmt::format("SH_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,16);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1312,11 +1347,13 @@ private:
         }
         bb->setName(fmt::format("SW_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,17);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1363,11 +1400,13 @@ private:
         }
         bb->setName(fmt::format("ADDI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,18);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1413,11 +1452,13 @@ private:
         }
         bb->setName(fmt::format("SLTI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,19);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1465,11 +1506,13 @@ private:
         }
         bb->setName(fmt::format("SLTIU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,20);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1516,11 +1559,13 @@ private:
         }
         bb->setName(fmt::format("XORI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,21);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1564,11 +1609,13 @@ private:
         }
         bb->setName(fmt::format("ORI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,22);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1612,11 +1659,13 @@ private:
         }
         bb->setName(fmt::format("ANDI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,23);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1660,11 +1709,13 @@ private:
         }
         bb->setName(fmt::format("SLLI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,24);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1708,11 +1759,13 @@ private:
         }
         bb->setName(fmt::format("SRLI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,25);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1756,11 +1809,13 @@ private:
         }
         bb->setName(fmt::format("SRAI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,26);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1806,11 +1861,13 @@ private:
         }
         bb->setName(fmt::format("ADD_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,27);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1856,11 +1913,13 @@ private:
         }
         bb->setName(fmt::format("SUB_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,28);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1906,11 +1965,13 @@ private:
         }
         bb->setName(fmt::format("SLL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,29);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -1957,11 +2018,13 @@ private:
         }
         bb->setName(fmt::format("SLT_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,30);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2010,11 +2073,13 @@ private:
         }
         bb->setName(fmt::format("SLTU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,31);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2061,11 +2126,13 @@ private:
         }
         bb->setName(fmt::format("XOR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,32);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2109,11 +2176,13 @@ private:
         }
         bb->setName(fmt::format("SRL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,33);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2160,11 +2229,13 @@ private:
         }
         bb->setName(fmt::format("SRA_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,34);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2214,11 +2285,13 @@ private:
         }
         bb->setName(fmt::format("OR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,35);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2262,11 +2335,13 @@ private:
         }
         bb->setName(fmt::format("AND_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,36);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2312,11 +2387,13 @@ private:
         }
         bb->setName(fmt::format("FENCE_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,37);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
         static_cast<uint32_t>(traits::fence),
@@ -2336,14 +2413,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "ecall";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("ECALL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,38);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, 11);
         bb = this->leave_blk;
@@ -2361,14 +2447,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "ebreak";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("EBREAK_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,39);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = this->leave_blk;
@@ -2386,14 +2481,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "mret";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("MRET_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,40);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_leave_trap(3);
         bb = this->leave_blk;
@@ -2411,14 +2515,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "wfi";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("WFI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,41);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_wait(1);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2450,11 +2563,13 @@ private:
         }
         bb->setName(fmt::format("CSRRW_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,42);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2504,11 +2619,13 @@ private:
         }
         bb->setName(fmt::format("CSRRS_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,43);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2559,11 +2676,13 @@ private:
         }
         bb->setName(fmt::format("CSRRC_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,44);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2614,11 +2733,13 @@ private:
         }
         bb->setName(fmt::format("CSRRWI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,45);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2663,11 +2784,13 @@ private:
         }
         bb->setName(fmt::format("CSRRSI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,46);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2717,11 +2840,13 @@ private:
         }
         bb->setName(fmt::format("CSRRCI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,47);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2771,11 +2896,13 @@ private:
         }
         bb->setName(fmt::format("FENCE_I_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,48);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
         static_cast<uint32_t>(traits::fencei),
@@ -2809,11 +2936,13 @@ private:
         }
         bb->setName(fmt::format("MUL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,49);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2862,11 +2991,13 @@ private:
         }
         bb->setName(fmt::format("MULH_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,50);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2918,11 +3049,13 @@ private:
         }
         bb->setName(fmt::format("MULHSU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,51);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2973,11 +3106,13 @@ private:
         }
         bb->setName(fmt::format("MULHU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,52);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3027,11 +3162,13 @@ private:
         }
         bb->setName(fmt::format("DIV_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,53);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3125,11 +3262,13 @@ private:
         }
         bb->setName(fmt::format("DIVU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,54);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3194,11 +3333,13 @@ private:
         }
         bb->setName(fmt::format("REM_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,55);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3296,11 +3437,13 @@ private:
         }
         bb->setName(fmt::format("REMU_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,56);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3364,11 +3507,13 @@ private:
         }
         bb->setName(fmt::format("C__ADDI4SPN_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,57);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(imm) {
             this->builder.CreateStore(
@@ -3412,11 +3557,13 @@ private:
         }
         bb->setName(fmt::format("C__LW_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,58);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         auto offs =this->gen_ext(
             (this->builder.CreateAdd(
@@ -3460,11 +3607,13 @@ private:
         }
         bb->setName(fmt::format("C__SW_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,59);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         auto offs =this->gen_ext(
             (this->builder.CreateAdd(
@@ -3505,11 +3654,13 @@ private:
         }
         bb->setName(fmt::format("C__ADDI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,60);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3542,14 +3693,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "c__nop";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("C__NOP_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,61);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3578,11 +3738,13 @@ private:
         }
         bb->setName(fmt::format("C__JAL_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,62);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->gen_const(32,(uint32_t)(PC+2)),
@@ -3618,11 +3780,13 @@ private:
         }
         bb->setName(fmt::format("C__LI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,63);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3662,11 +3826,13 @@ private:
         }
         bb->setName(fmt::format("C__LUI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,64);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3703,11 +3869,13 @@ private:
         }
         bb->setName(fmt::format("C__ADDI16SP_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,65);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(nzimm) {
             this->builder.CreateStore(
@@ -3738,14 +3906,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "__reserved_clui";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("__reserved_clui_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,66);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3776,11 +3953,13 @@ private:
         }
         bb->setName(fmt::format("C__SRLI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,67);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->builder.CreateLShr(
@@ -3816,11 +3995,13 @@ private:
         }
         bb->setName(fmt::format("C__SRAI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,68);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(shamt){ this->builder.CreateStore(
              this->gen_ext(
@@ -3874,11 +4055,13 @@ private:
         }
         bb->setName(fmt::format("C__ANDI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,69);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->gen_ext(
@@ -3916,11 +4099,13 @@ private:
         }
         bb->setName(fmt::format("C__SUB_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,70);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->gen_ext(
@@ -3958,11 +4143,13 @@ private:
         }
         bb->setName(fmt::format("C__XOR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,71);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->builder.CreateXor(
@@ -3998,11 +4185,13 @@ private:
         }
         bb->setName(fmt::format("C__OR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,72);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->builder.CreateOr(
@@ -4038,11 +4227,13 @@ private:
         }
         bb->setName(fmt::format("C__AND_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,73);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
              this->builder.CreateAnd(
@@ -4077,11 +4268,13 @@ private:
         }
         bb->setName(fmt::format("C__J_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,74);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
@@ -4114,11 +4307,13 @@ private:
         }
         bb->setName(fmt::format("C__BEQZ_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,75);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
@@ -4162,11 +4357,13 @@ private:
         }
         bb->setName(fmt::format("C__BNEZ_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,76);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
@@ -4210,11 +4407,13 @@ private:
         }
         bb->setName(fmt::format("C__SLLI_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,77);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4257,11 +4456,13 @@ private:
         }
         bb->setName(fmt::format("C__LWSP_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,78);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4309,11 +4510,13 @@ private:
         }
         bb->setName(fmt::format("C__MV_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,79);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4352,11 +4555,13 @@ private:
         }
         bb->setName(fmt::format("C__JR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,80);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
         auto PC_val_v = this->builder.CreateAnd(
@@ -4384,14 +4589,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "__reserved_cmv";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("__reserved_cmv_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,81);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, 2);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4422,11 +4636,13 @@ private:
         }
         bb->setName(fmt::format("C__ADD_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,82);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4470,11 +4686,13 @@ private:
         }
         bb->setName(fmt::format("C__JALR_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,83);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4507,14 +4725,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "c__ebreak";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("C__EBREAK_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,84);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4545,11 +4772,13 @@ private:
         }
         bb->setName(fmt::format("C__SWSP_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,85);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -4582,14 +4811,23 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             //This disass is not yet implemented
+            std::string mnemonic = "dii";
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
         bb->setName(fmt::format("DII_0x{:X}",pc.val));
         this->gen_sync(PRE_SYNC,86);
-        auto cur_pc_val = this->gen_const(32,pc.val);
+        
+        this->gen_set_pc(pc, traits::PC);
+        this->set_tval(instr);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(instr);
-
+        
+        this->gen_instr_prologue();
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4741,15 +4979,12 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_raise_trap(uint16_t trap_id, uint16_t cause) {
     auto *TRAP_val = this->gen_const(32, 0x80 << 24 | (cause << 16) | trap_id);
     this->builder.CreateStore(TRAP_val, get_reg_ptr(traits::TRAP_STATE), true);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
 template <typename ARCH>
 void vm_impl<ARCH>::gen_leave_trap(unsigned lvl) {
     std::vector<Value *> args{ this->core_ptr, ConstantInt::get(getContext(), APInt(64, lvl)) };
     this->builder.CreateCall(this->mod->getFunction("leave_trap"), args);
-    auto *PC_val = this->gen_read_mem(traits::CSR, (lvl << 8) + 0x41, traits::XLEN / 8);
-    this->builder.CreateStore(PC_val, get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
@@ -4772,14 +5007,24 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
-                              get_reg_ptr(traits::LAST_BRANCH), false);
-    std::vector<Value *> args{this->core_ptr, this->adj_to64(trap_state_val),
+    auto *cur_pc_val = this->builder.CreateLoad(this->get_typeptr(traits::PC), get_reg_ptr(traits::PC), true);
+    std::vector<Value *> args{this->core_ptr,
+                                this->adj_to64(trap_state_val),
+                                this->adj_to64(cur_pc_val),
                               this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
+    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);
 }
+template <typename ARCH>
+void vm_impl<ARCH>::gen_instr_prologue() {
+    auto* trap_val =
+        this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::PENDING_TRAP), get_reg_ptr(arch::traits<ARCH>::PENDING_TRAP));
+    this->builder.CreateStore(trap_val, get_reg_ptr(arch::traits<ARCH>::TRAP_STATE), false);
+}
+            
 
 template <typename ARCH>
 void vm_impl<ARCH>::gen_instr_epilogue(BasicBlock *bb) {
@@ -4790,6 +5035,10 @@ void vm_impl<ARCH>::gen_instr_epilogue(BasicBlock *bb) {
                               ConstantInt::get(getContext(), APInt(v->getType()->getIntegerBitWidth(), 0))),
                           target_bb, this->trap_blk, 1);
     this->builder.SetInsertPoint(target_bb);
+    // update icount
+    auto* icount_val = this->builder.CreateAdd(
+        this->builder.CreateLoad(this->get_typeptr(arch::traits<ARCH>::ICOUNT), get_reg_ptr(arch::traits<ARCH>::ICOUNT)), this->gen_const(64U, 1));
+    this->builder.CreateStore(icount_val, get_reg_ptr(arch::traits<ARCH>::ICOUNT), false);
 }
 
 } // namespace tgc5c

From 236d12d7f5cfb98ee1e742b11ca9d9b837102c21 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 18 Jul 2024 13:30:42 +0200
Subject: [PATCH 032/100] integrates gen_bool for Conditions (was truncation)
 into llvm

---
 src/vm/llvm/vm_tgc5c.cpp | 60 ++++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 19bc91b..0572697 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -522,10 +522,10 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateURem(
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateURem(
                new_pc,
                this->gen_const(32,static_cast<uint32_t>(traits::INSTR_ALIGNMENT)))
-            , 1), bb_then, bb_else);
+            ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 this->set_tval(new_pc);
@@ -589,10 +589,10 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                this->gen_reg_load(rs1+ traits::X0, 0),
                this->gen_reg_load(rs2+ traits::X0, 0))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -651,10 +651,10 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
                this->gen_reg_load(rs1+ traits::X0, 0),
                this->gen_reg_load(rs2+ traits::X0, 0))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -713,14 +713,14 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
                this->gen_ext(
                    this->gen_reg_load(rs1+ traits::X0, 0),
                    32, false),
                this->gen_ext(
                    this->gen_reg_load(rs2+ traits::X0, 0),
                    32, false))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -779,14 +779,14 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_SGE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SGE,
                this->gen_ext(
                    this->gen_reg_load(rs1+ traits::X0, 0),
                    32, false),
                this->gen_ext(
                    this->gen_reg_load(rs2+ traits::X0, 0),
                    32, false))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -845,10 +845,10 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
                this->gen_reg_load(rs1+ traits::X0, 0),
                this->gen_reg_load(rs2+ traits::X0, 0))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -907,10 +907,10 @@ private:
         else{
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_UGE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_UGE,
                this->gen_reg_load(rs1+ traits::X0, 0),
                this->gen_reg_load(rs2+ traits::X0, 0))
-            , 1), bb_then,  bb_merge);
+            ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto new_pc =(uint32_t)(PC+(int16_t)sext<13>(imm));
@@ -3181,17 +3181,17 @@ private:
             if(rd!=0){ auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
                divisor,
                this->gen_ext(this->gen_const(8,0), 32,false))
-            , 1), bb_then, bb_else);
+            ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto MMIN =((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-                this->builder.CreateCondBr(this->gen_ext(this->builder.CreateAnd(
+                this->builder.CreateCondBr(this->gen_bool(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_reg_load(rs1+ traits::X0, 0),
                       this->gen_const(32,MMIN))
@@ -3200,7 +3200,7 @@ private:
                       divisor,
                       this->gen_ext(this->gen_const(8,- 1), 32,true))
                    )
-                , 1), bb_then, bb_else);
+                ), bb_then, bb_else);
                 this->builder.SetInsertPoint(bb_then);
                 {
                     this->builder.CreateStore(
@@ -3277,10 +3277,10 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
                this->gen_reg_load(rs2+ traits::X0, 0),
                this->gen_ext(this->gen_const(8,0), 32,false))
-            , 1), bb_then, bb_else);
+            ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 if(rd!=0) {
@@ -3348,17 +3348,17 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
                this->gen_reg_load(rs2+ traits::X0, 0),
                this->gen_ext(this->gen_const(8,0), 32,false))
-            , 1), bb_then, bb_else);
+            ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 auto MMIN =(uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-                this->builder.CreateCondBr(this->gen_ext(this->builder.CreateAnd(
+                this->builder.CreateCondBr(this->gen_bool(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_reg_load(rs1+ traits::X0, 0),
                       this->gen_const(32,MMIN))
@@ -3369,7 +3369,7 @@ private:
                           32, false),
                       this->gen_ext(this->gen_const(8,- 1), 32,true))
                    )
-                , 1), bb_then, bb_else);
+                ), bb_then, bb_else);
                 this->builder.SetInsertPoint(bb_then);
                 {
                     if(rd!=0) {
@@ -3452,10 +3452,10 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
-            this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+            this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
                this->gen_reg_load(rs2+ traits::X0, 0),
                this->gen_ext(this->gen_const(8,0), 32,false))
-            , 1), bb_then, bb_else);
+            ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 if(rd!=0) {
@@ -4317,10 +4317,10 @@ private:
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-        this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
+        this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
            this->gen_reg_load(rs1+8+ traits::X0, 0),
            this->gen_ext(this->gen_const(8,0), 32,false))
-        , 1), bb_then,  bb_merge);
+        ), bb_then,  bb_merge);
         this->builder.SetInsertPoint(bb_then);
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
@@ -4367,10 +4367,10 @@ private:
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
-        this->builder.CreateCondBr(this->gen_ext(this->builder.CreateICmp(ICmpInst::ICMP_NE,
+        this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
            this->gen_reg_load(rs1+8+ traits::X0, 0),
            this->gen_ext(this->gen_const(8,0), 32,false))
-        , 1), bb_then,  bb_merge);
+        ), bb_then,  bb_merge);
         this->builder.SetInsertPoint(bb_then);
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));

From d42d2ce533bfb6154c8bb43175041953b499d076 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 18 Jul 2024 14:04:23 +0200
Subject: [PATCH 033/100] corrects illegal instruction for llvm

---
 gen_input/templates/llvm/CORENAME.cpp.gtl | 4 +++-
 src/vm/llvm/vm_tgc5c.cpp                  | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 0c7f3e0..c48ffe0 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -214,7 +214,9 @@ private:
         this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
-        this->gen_instr_epilogue(this->leave_blk);
+        bb = this->leave_blk;
+        this->gen_instr_epilogue(bb);
+        this->builder.CreateBr(bb);
         return std::make_tuple(BRANCH, nullptr);
     }    
     //decoding functionality
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 0572697..7fda2bb 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -4863,7 +4863,9 @@ private:
         this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
-        this->gen_instr_epilogue(this->leave_blk);
+        bb = this->leave_blk;
+        this->gen_instr_epilogue(bb);
+        this->builder.CreateBr(bb);
         return std::make_tuple(BRANCH, nullptr);
     }    
     //decoding functionality

From 4f5d9214ed6b75167b0e47f17c4d722997a950f0 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 18 Jul 2024 14:31:36 +0200
Subject: [PATCH 034/100] adds newly generated instr.yaml

---
 contrib/instr/TGC5C_instr.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/instr/TGC5C_instr.yaml b/contrib/instr/TGC5C_instr.yaml
index c28b051..1663d37 100644
--- a/contrib/instr/TGC5C_instr.yaml
+++ b/contrib/instr/TGC5C_instr.yaml
@@ -20,7 +20,7 @@ RVI:
     mask: 0b00000000000000000000000001111111
     size:   32
     branch:   true
-    delay:   [1,1]
+    delay:   1
   JALR:
     index: 3
     encoding: 0b00000000000000000000000001100111

From 0432803d82e2604c2f08ed35dfae3b965ee45a9b Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 22 Jul 2024 09:04:17 +0200
Subject: [PATCH 035/100] updates templates and vm impls for better LAST_BRANCH
 handling

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |  2 +-
 gen_input/templates/llvm/CORENAME.cpp.gtl   |  4 +-
 gen_input/templates/tcc/CORENAME.cpp.gtl    |  5 +--
 src/vm/asmjit/vm_tgc5c.cpp                  | 47 ++++++++++++-------
 src/vm/llvm/vm_tgc5c.cpp                    | 49 +++++++++++++-------
 src/vm/tcc/vm_tgc5c.cpp                     | 50 ++++++++++++++-------
 6 files changed, 103 insertions(+), 54 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index eb7cb3d..55ab9d6 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -347,7 +347,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
     mov(cc, jh.next_pc, current_next_pc);
 
-    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
+    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
     cc.ret(jh.next_pc);
 }
 template <typename ARCH>
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index c48ffe0..3d3ebfb 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -338,7 +338,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_leave_trap(unsigned lvl) {
     std::vector<Value *> args{ this->core_ptr, ConstantInt::get(getContext(), APInt(64, lvl)) };
     this->builder.CreateCall(this->mod->getFunction("leave_trap"), args);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+    this->builder.CreateStore(this->gen_const(32U, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
 template <typename ARCH>
@@ -366,7 +366,7 @@ void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
                                 this->adj_to64(cur_pc_val),
                               this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+    this->builder.CreateStore(this->gen_const(32U, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
 
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 3480e56..a6e2f64 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -302,13 +302,12 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 
 template <typename ARCH> void vm_impl<ARCH>::gen_raise_trap(tu_builder& tu, uint16_t trap_id, uint16_t cause) {
     tu("  *trap_state = {:#x};", 0x80 << 24 | (cause << 16) | trap_id);
-    tu.store(traits::NEXT_PC, tu.constant(std::numeric_limits<uint32_t>::max(), 32));
 }
 
 template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsigned lvl) {
     tu("leave_trap(core_ptr, {});", lvl);
     tu.store(traits::NEXT_PC, tu.read_mem(traits::CSR, (lvl << 8) + 0x41, traits::XLEN));
-    tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(), 32));
+    tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 32));
 }
 
 template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
@@ -325,7 +324,7 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu("trap_entry:");
     this->gen_sync(tu, POST_SYNC, -1);    
     tu("enter_trap(core_ptr, *trap_state, *pc, tval);");
-    tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(),32));
+    tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP),32));
     tu("return *next_pc;");
 }
 
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index da56508..df92a8e 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -440,6 +440,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rd>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -456,7 +457,7 @@ private:
                 }
                 auto PC_val_v = new_pc;
                 mov(cc, jh.next_pc, PC_val_v);
-                mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
             }
         }
         auto returnValue = BRANCH;
@@ -498,6 +499,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -525,7 +527,7 @@ private:
                     }
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
                 }
             cc.bind(label_merge);
         }
@@ -568,6 +570,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -585,7 +588,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -629,6 +632,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -646,7 +650,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -690,6 +694,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -709,7 +714,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -753,6 +758,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -772,7 +778,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -816,6 +822,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -833,7 +840,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -877,6 +884,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -894,7 +902,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     mov(cc, jh.next_pc, PC_val_v);
-                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+                    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
                 }
             }
             cc.bind(label_merge);
@@ -2387,6 +2395,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         gen_raise(jh, 0, 11);
         auto returnValue = TRAP;
         
@@ -2423,6 +2432,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         gen_raise(jh, 0, 3);
         auto returnValue = TRAP;
         
@@ -2459,6 +2469,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         gen_leave(jh, 3);
         auto returnValue = TRAP;
         
@@ -3629,11 +3640,12 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         mov(cc, get_ptr_for(jh, traits::X0+ 1),
               (uint32_t)(PC+2));
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         mov(cc, jh.next_pc, PC_val_v);
-        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         auto returnValue = BRANCH;
         
         gen_sync(jh, POST_SYNC, 62);
@@ -4148,9 +4160,10 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         mov(cc, jh.next_pc, PC_val_v);
-        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+        mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         auto returnValue = BRANCH;
         
         gen_sync(jh, POST_SYNC, 74);
@@ -4189,6 +4202,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         auto label_merge = cc.newLabel();
         cmp(cc, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
@@ -4196,7 +4210,7 @@ private:
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
             mov(cc, jh.next_pc, PC_val_v);
-            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         }
         cc.bind(label_merge);
         auto returnValue = BRANCH;
@@ -4237,6 +4251,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         auto label_merge = cc.newLabel();
         cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
@@ -4244,7 +4259,7 @@ private:
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
             mov(cc, jh.next_pc, PC_val_v);
-            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         }
         cc.bind(label_merge);
         auto returnValue = BRANCH;
@@ -4429,12 +4444,13 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){
             auto addr_mask = (uint32_t)- 2;
             auto PC_val_v = gen_operation(cc, band, load_reg_from_mem(jh, traits::X0 + rs1%static_cast<uint32_t>(traits::RFS)), addr_mask)
             ;
             mov(cc, jh.next_pc, PC_val_v);
-            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
         }
         else{
             gen_raise(jh, 0, 2);
@@ -4561,6 +4577,7 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
+        mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
         if(rs1>=static_cast<uint32_t>(traits::RFS)){
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -4572,7 +4589,7 @@ private:
             auto PC_val_v = gen_operation(cc, band, new_pc, addr_mask)
             ;
             mov(cc, jh.next_pc, PC_val_v);
-            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), 32U);
+            mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
         }
         auto returnValue = BRANCH;
         
@@ -4870,7 +4887,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
     mov(cc, jh.next_pc, current_next_pc);
 
-    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), std::numeric_limits<uint32_t>::max());
+    mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
     cc.ret(jh.next_pc);
 }
 template <typename ARCH>
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 7fda2bb..bd86bb8 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -449,6 +449,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -465,7 +466,7 @@ private:
                 }
                 auto PC_val_v = new_pc;
                 this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
             }
         }
         bb = this->leave_blk;
@@ -505,6 +506,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -541,7 +543,7 @@ private:
                 }
                 auto PC_val_v = new_pc;
                 this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
-                this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                this->builder.CreateStore(this->gen_const(32, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
@@ -583,6 +585,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -602,7 +605,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -645,6 +648,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -664,7 +668,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -707,6 +711,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -730,7 +735,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -773,6 +778,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -796,7 +802,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -839,6 +845,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -858,7 +865,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -901,6 +908,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -920,7 +928,7 @@ private:
                 else{
                     auto PC_val_v = new_pc;
                     this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-                    this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+                    this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -2431,6 +2439,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         this->gen_raise_trap(0, 11);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
@@ -2465,6 +2474,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         this->gen_raise_trap(0, 3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
@@ -2499,6 +2509,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         this->gen_leave_trap(3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
@@ -3746,12 +3757,13 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         this->builder.CreateStore(
              this->gen_const(32,(uint32_t)(PC+2)),
              get_reg_ptr(1 + traits::X0), false);
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-        this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+        this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
@@ -4276,9 +4288,10 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-        this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+        this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
@@ -4315,6 +4328,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
@@ -4325,7 +4339,7 @@ private:
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
             this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-            this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+            this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         }
         this->builder.CreateBr(bb_merge);
         this->builder.SetInsertPoint(bb_merge);
@@ -4365,6 +4379,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
@@ -4375,7 +4390,7 @@ private:
         {
             auto PC_val_v = (uint32_t)(PC+(int16_t)sext<9>(imm));
             this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
-            this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+            this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         }
         this->builder.CreateBr(bb_merge);
         this->builder.SetInsertPoint(bb_merge);
@@ -4563,13 +4578,14 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
         auto PC_val_v = this->builder.CreateAnd(
            this->gen_reg_load(rs1%static_cast<uint32_t>(traits::RFS)+ traits::X0, 0),
            this->gen_const(32,addr_mask))
         ;
         this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
-        this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+        this->builder.CreateStore(this->gen_const(32, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         }
         else{
             this->gen_raise_trap(0, 2);
@@ -4694,6 +4710,7 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
+        this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -4708,7 +4725,7 @@ private:
                this->gen_const(32,addr_mask))
             ;
             this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
-            this->builder.CreateStore(this->gen_const(32,2U), get_reg_ptr(traits::LAST_BRANCH), false);
+            this->builder.CreateStore(this->gen_const(32, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -4987,7 +5004,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_leave_trap(unsigned lvl) {
     std::vector<Value *> args{ this->core_ptr, ConstantInt::get(getContext(), APInt(64, lvl)) };
     this->builder.CreateCall(this->mod->getFunction("leave_trap"), args);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+    this->builder.CreateStore(this->gen_const(32U, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
 }
 
 template <typename ARCH>
@@ -5015,7 +5032,7 @@ void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
                                 this->adj_to64(cur_pc_val),
                               this->adj_to64(this->builder.CreateLoad(this->get_type(64),this->tval))};
     this->builder.CreateCall(this->mod->getFunction("enter_trap"), args);
-    this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()), get_reg_ptr(traits::LAST_BRANCH), false);
+    this->builder.CreateStore(this->gen_const(32U, static_cast<int>(UNKNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
 
     auto *trap_addr_val = this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), false);
     this->builder.CreateRet(trap_addr_val);
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 1c23d54..afdfbc6 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -422,6 +422,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rd>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -437,7 +438,7 @@ private:
         		}
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -468,6 +469,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rd>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -490,7 +492,7 @@ private:
         	}
         	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -521,6 +523,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -535,7 +538,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -567,6 +570,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -581,7 +585,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -613,6 +617,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -627,7 +632,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -659,6 +664,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -673,7 +679,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -705,6 +711,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -719,7 +726,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -751,6 +758,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs2>=static_cast<uint32_t>(traits:: RFS)||rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -765,7 +773,7 @@ private:
         	else{
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
-        		tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
         	tu.close_scope();
         }
@@ -1885,6 +1893,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         this->gen_raise_trap(tu, 0, 11);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -1908,6 +1917,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         this->gen_raise_trap(tu, 0, 3);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -1931,6 +1941,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         this->gen_leave_trap(tu, 3);
         auto returnValue = std::make_tuple(TRAP);
         
@@ -2810,11 +2821,12 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.store(1 + traits::X0,
               tu.constant((uint32_t)(PC+2),32));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
@@ -3195,9 +3207,10 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         auto returnValue = std::make_tuple(BRANCH);
         
         tu.close_scope();
@@ -3225,12 +3238,13 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -3259,12 +3273,13 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
            tu.load(rs1+8+ traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -3403,12 +3418,13 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = (uint32_t)- 2;
         auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
            tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
            tu.constant(addr_mask,32)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
-        tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
         }
         else{
         	this->gen_raise_trap(tu, 0, 2);
@@ -3500,6 +3516,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
+        tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs1>=static_cast<uint32_t>(traits:: RFS)) {
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
@@ -3512,7 +3529,7 @@ private:
         	   new_pc,
         	   tu.constant(addr_mask,32)),32);
         	tu.store(traits::NEXT_PC, PC_val_v);
-        	tu.store(traits::LAST_BRANCH, tu.constant(2U, 2));
+        	tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
         }
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -3724,13 +3741,12 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 
 template <typename ARCH> void vm_impl<ARCH>::gen_raise_trap(tu_builder& tu, uint16_t trap_id, uint16_t cause) {
     tu("  *trap_state = {:#x};", 0x80 << 24 | (cause << 16) | trap_id);
-    tu.store(traits::NEXT_PC, tu.constant(std::numeric_limits<uint32_t>::max(), 32));
 }
 
 template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsigned lvl) {
     tu("leave_trap(core_ptr, {});", lvl);
     tu.store(traits::NEXT_PC, tu.read_mem(traits::CSR, (lvl << 8) + 0x41, traits::XLEN));
-    tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(), 32));
+    tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 32));
 }
 
 template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
@@ -3747,7 +3763,7 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu("trap_entry:");
     this->gen_sync(tu, POST_SYNC, -1);    
     tu("enter_trap(core_ptr, *trap_state, *pc, tval);");
-    tu.store(traits::LAST_BRANCH, tu.constant(std::numeric_limits<uint32_t>::max(),32));
+    tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP),32));
     tu("return *next_pc;");
 }
 

From 60808c86492a11d0c6fe71c3e3881f466bc2d286 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 11:29:56 +0200
Subject: [PATCH 036/100] corrects template since util fns are no longer
 vm_base members

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 6 ------
 src/vm/asmjit/vm_tgc5c.cpp                  | 6 ------
 2 files changed, 12 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 55ab9d6..45c60b7 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -79,22 +79,16 @@ public:
     }
 
 protected:
-    using super::mov;
-    using super::cmp;
     using super::get_ptr_for;
-    using super::get_reg;
-    using super::get_reg_Gp;
     using super::get_reg_for;
     using super::get_reg_for_Gp;
     using super::load_reg_from_mem;
     using super::load_reg_from_mem_Gp;
     using super::write_reg_to_mem;
-    using super::gen_ext;
     using super::gen_read_mem;
     using super::gen_write_mem;
     using super::gen_wait;
     using super::gen_leave;
-    using super::gen_operation;
     using super::gen_sync;
     using super::gen_set_tval;
    
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index df92a8e..d967dc3 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -79,22 +79,16 @@ public:
     }
 
 protected:
-    using super::mov;
-    using super::cmp;
     using super::get_ptr_for;
-    using super::get_reg;
-    using super::get_reg_Gp;
     using super::get_reg_for;
     using super::get_reg_for_Gp;
     using super::load_reg_from_mem;
     using super::load_reg_from_mem_Gp;
     using super::write_reg_to_mem;
-    using super::gen_ext;
     using super::gen_read_mem;
     using super::gen_write_mem;
     using super::gen_wait;
     using super::gen_leave;
-    using super::gen_operation;
     using super::gen_sync;
     using super::gen_set_tval;
    

From 6ee484a771611fad3ccfe26245dd8b8500bfee06 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 11:30:33 +0200
Subject: [PATCH 037/100] moves instruction decoder into own class

---
 CMakeLists.txt                 |   1 +
 src/vm/instruction_decoder.cpp | 103 +++++++++++++++++++++++++++++++++
 src/vm/instruction_decoder.h   |  63 ++++++++++++++++++++
 3 files changed, 167 insertions(+)
 create mode 100644 src/vm/instruction_decoder.cpp
 create mode 100644 src/vm/instruction_decoder.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2a46f47..b8dd450 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,7 @@ set(LIB_SOURCES
     src/iss/arch/tgc5c.cpp
     src/vm/interp/vm_tgc5c.cpp
     src/vm/fp_functions.cpp
+    src/vm/instruction_decoder.cpp
     src/iss/semihosting/semihosting.cpp
 )
 
diff --git a/src/vm/instruction_decoder.cpp b/src/vm/instruction_decoder.cpp
new file mode 100644
index 0000000..b975d81
--- /dev/null
+++ b/src/vm/instruction_decoder.cpp
@@ -0,0 +1,103 @@
+/*******************************************************************************
+ * Copyright (C) 2024 MINRES Technologies GmbH
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contributors:
+ *       alex@minres.com - initial implementation
+ ******************************************************************************/
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <numeric>
+#include <vector>
+#include <vm/instruction_decoder.h>
+
+decoder::decoder(std::vector<generic_instruction_descriptor> instr_list) {
+    for(auto instr : instr_list) {
+        root.instrs.push_back(instr);
+    }
+    populate_decoding_tree(root);
+}
+
+void decoder::populate_decoding_tree(decoding_tree_node& parent) {
+    // create submask
+    parent.submask =
+        std::accumulate(parent.instrs.begin(), parent.instrs.end(), std::numeric_limits<uint32_t>::max(),
+                        [](int current_submask, const generic_instruction_descriptor& instr) { return current_submask & instr.mask; });
+    //  put each instr according to submask&encoding into children
+    for(auto instr : parent.instrs) {
+        bool foundMatch = false;
+        for(auto& child : parent.children) {
+            // use value as identifying trait
+            if(child.value == (instr.value & parent.submask)) {
+                child.instrs.push_back(instr);
+                foundMatch = true;
+            }
+        }
+        if(!foundMatch) {
+            decoding_tree_node child = decoding_tree_node(instr.value & parent.submask);
+            child.instrs.push_back(instr);
+            parent.children.push_back(child);
+        }
+    }
+    parent.instrs.clear();
+    // call populate_decoding_tree for all children
+    if(parent.children.size() > 1)
+        for(auto& child : parent.children) {
+            populate_decoding_tree(child);
+        }
+    else {
+        // sort instrs by value of the mask, so we have the least restrictive mask last
+        std::sort(parent.children[0].instrs.begin(), parent.children[0].instrs.end(),
+                  [](const generic_instruction_descriptor& instr1, const generic_instruction_descriptor& instr2) {
+                      return instr1.mask > instr2.mask;
+                  });
+    }
+}
+uint32_t decoder::decode_instr(uint32_t word) { return _decode_instr(this->root, word); }
+uint32_t decoder::_decode_instr(decoding_tree_node const& node, uint32_t word) {
+    if(!node.children.size()) {
+        if(node.instrs.size() == 1)
+            return node.instrs[0].index;
+        for(auto instr : node.instrs) {
+            if((instr.mask & word) == instr.value)
+                return instr.index;
+        }
+    } else {
+        for(auto child : node.children) {
+            if(child.value == (node.submask & word)) {
+                return _decode_instr(child, word);
+            }
+        }
+    }
+    return std::numeric_limits<uint32_t>::max();
+}
diff --git a/src/vm/instruction_decoder.h b/src/vm/instruction_decoder.h
new file mode 100644
index 0000000..c1e8aac
--- /dev/null
+++ b/src/vm/instruction_decoder.h
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (C) 2024 MINRES Technologies GmbH
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contributors:
+ *       alex@minres.com - initial implementation
+ ******************************************************************************/
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <vector>
+
+struct generic_instruction_descriptor {
+    uint32_t value;
+    uint32_t mask;
+    uint32_t index;
+};
+
+struct decoding_tree_node {
+    std::vector<generic_instruction_descriptor> instrs;
+    std::vector<decoding_tree_node> children;
+    uint32_t submask = std::numeric_limits<uint32_t>::max();
+    uint32_t value;
+    decoding_tree_node(uint32_t value)
+    : value(value) {}
+};
+class decoder {
+public:
+    decoder(std::vector<generic_instruction_descriptor> instr_list);
+    uint32_t decode_instr(uint32_t word);
+
+private:
+    decoding_tree_node root{decoding_tree_node(std::numeric_limits<uint32_t>::max())};
+    void populate_decoding_tree(decoding_tree_node& root);
+    uint32_t _decode_instr(decoding_tree_node const& node, uint32_t word);
+};
\ No newline at end of file

From e3942be7767ced192027fcbaa2a4393d89789462 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 13:08:53 +0200
Subject: [PATCH 038/100] Introduces decoder in a seperate class

---
 src/vm/asmjit/vm_tgc5c.cpp | 90 ++++++++---------------------------
 src/vm/interp/vm_tgc5c.cpp | 92 +++++++++---------------------------
 src/vm/llvm/vm_tgc5c.cpp   | 93 +++++++++---------------------------
 src/vm/tcc/vm_tgc5c.cpp    | 96 +++++++++-----------------------------
 4 files changed, 83 insertions(+), 288 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index d967dc3..00b7f4a 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -37,6 +37,7 @@
 #include <iss/asmjit/vm_base.h>
 #include <asmjit/asmjit.h>
 #include <util/logging.h>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -115,20 +116,11 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, 87> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */
@@ -307,6 +299,9 @@ private:
         /* instruction DII, encoding '0b0000000000000000' */
         {16, 0b0000000000000000, 0b1111111111111111, &this_class::__dii},
     }};
+
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
  
     /* instruction definitions */
     /* instruction 0: LUI */
@@ -4740,72 +4735,22 @@ private:
         gen_instr_epilogue(jh);
         return BRANCH;
     }
-     
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr: instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt, jit_holder& jh) {
@@ -4821,7 +4766,10 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
     if (instr == 0x0000006f || (instr&0xffff)==0xa001)
         throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) 
         f = &this_class::illegal_instruction;
     return (this->*f)(pc, instr, jh);
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 135ab8c..64b716e 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -31,6 +31,7 @@
  *******************************************************************************/
 
 // clang-format off
+#include <cstdint>
 #include <iss/arch/tgc5c.h>
 #include <iss/debugger/gdb_session.h>
 #include <iss/debugger/server.h>
@@ -43,6 +44,7 @@
 #include <exception>
 #include <vector>
 #include <sstream>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -146,20 +148,11 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         typename arch::traits<ARCH>::opcode_e op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
     const std::array<instruction_descriptor, 87> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */
         {32, 0b00000000000000000000000000110111, 0b00000000000000000000000001111111, arch::traits<ARCH>::opcode_e::LUI},
@@ -250,6 +243,8 @@ private:
         {16, 0b1100000000000010, 0b1110000000000011, arch::traits<ARCH>::opcode_e::C__SWSP},
         {16, 0b0000000000000000, 0b1111111111111111, arch::traits<ARCH>::opcode_e::DII},
     }};
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
 
     iss::status fetch_ins(virt_addr_t pc, uint8_t * data){
         if(this->core.has_mmu()) {
@@ -270,58 +265,6 @@ private:
         }
         return iss::Ok;
     }
-    
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-
-    typename arch::traits<ARCH>::opcode_e  decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return arch::traits<ARCH>::opcode_e::MAX_OPCODE;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD insn) {
@@ -347,13 +290,16 @@ constexpr size_t bit_count(uint32_t u) {
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 inline bool is_icount_limit_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
@@ -390,9 +336,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
         } else {
             if (is_jump_to_self_enabled(cond) &&
                     (instr == 0x0000006f || (instr&0xffff)==0xa001)) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-            auto inst_id = decode_instr(root, instr);
+            uint32_t inst_index = instr_decoder.decode_instr(instr);
+            opcode_e inst_id = arch::traits<ARCH>::opcode_e::MAX_OPCODE;;
+            if(inst_index <instr_descr.size())
+                inst_id = instr_descr.at(instr_decoder.decode_instr(instr)).op;
+
             // pre execution stuff
-             this->core.reg.last_branch = 0;
+            this->core.reg.last_branch = 0;
             if(this->sync_exec && PRE_SYNC) this->do_sync(PRE_SYNC, static_cast<unsigned>(inst_id));
             try{
                 switch(inst_id){
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index bd86bb8..cee7dd0 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -36,6 +36,7 @@
 #include <iss/iss.h>
 #include <iss/llvm/vm_base.h>
 #include <util/logging.h>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -136,20 +137,11 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, 87> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */
@@ -329,6 +321,9 @@ private:
         {16, 0b0000000000000000, 0b1111111111111111, &this_class::__dii},
     }};
  
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     /* instruction definitions */
     /* instruction 0: LUI */
     std::tuple<continuation_e, BasicBlock*> __lui(virt_addr_t& pc, code_word_t instr, BasicBlock* bb){
@@ -4885,58 +4880,6 @@ private:
         this->builder.CreateBr(bb);
         return std::make_tuple(BRANCH, nullptr);
     }    
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
@@ -4948,13 +4891,16 @@ template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 std::tuple<continuation_e, BasicBlock *>
@@ -4975,13 +4921,16 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 //            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
 //        }
 //    } else {
-        auto res = this->core.read(paddr, 4, data);
-        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
+    auto res = this->core.read(paddr, 4, data);
+    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
 //    }
     if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     // curr pc on stack
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) {
         f = &this_class::illegal_instruction;
     }
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index afdfbc6..ba61306 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -37,6 +37,7 @@
 #include <iss/tcc/vm_base.h>
 #include <util/logging.h>
 #include <sstream>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -137,20 +138,11 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, 87> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */
@@ -329,7 +321,10 @@ private:
         /* instruction DII, encoding '0b0000000000000000' */
         {16, 0b0000000000000000, 0b1111111111111111, &this_class::__dii},
     }};
- 
+
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     /* instruction definitions */
     /* instruction 0: LUI */
     compile_ret_t __lui(virt_addr_t& pc, code_word_t instr, tu_builder& tu){
@@ -3637,59 +3632,6 @@ private:
         vm_impl::gen_trap_check(tu);
         return BRANCH;
     }
-    
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
@@ -3701,13 +3643,16 @@ template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 std::tuple<continuation_e>
@@ -3726,13 +3671,16 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 //            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
 //        }
 //    } else {
-        auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
-        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
+    auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
+    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
 //    }
     if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     // curr pc on stack
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) {
         f = &this_class::illegal_instruction;
     }

From 051dd5e2d3da35b70b2af709cc86837fa70213bc Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 13:46:10 +0200
Subject: [PATCH 039/100] updates templates for decoder in seperate class, adds
 again generated templates

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 92 +++++--------------
 gen_input/templates/llvm/CORENAME.cpp.gtl   | 95 +++++---------------
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 98 +++++----------------
 src/vm/asmjit/vm_tgc5c.cpp                  |  2 +-
 src/vm/llvm/vm_tgc5c.cpp                    |  2 +-
 src/vm/tcc/vm_tgc5c.cpp                     |  2 +-
 6 files changed, 68 insertions(+), 223 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 45c60b7..5749f29 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -37,6 +37,7 @@
 #include <iss/asmjit/vm_base.h>
 #include <asmjit/asmjit.h>
 #include <util/logging.h>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -115,27 +116,21 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>
     }};
- 
+
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     /* instruction definitions */<%instructions.eachWithIndex{instr, idx -> %>
     /* instruction ${idx}: ${instr.name} */
     continuation_e __${generator.functionName(instr.name)}(virt_addr_t& pc, code_word_t instr, jit_holder& jh){
@@ -200,72 +195,22 @@ private:
         gen_instr_epilogue(jh);
         return BRANCH;
     }
-     
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr: instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt, jit_holder& jh) {
@@ -281,7 +226,10 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
     if (instr == 0x0000006f || (instr&0xffff)==0xa001)
         throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) 
         f = &this_class::illegal_instruction;
     return (this->*f)(pc, instr, jh);
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 3d3ebfb..517253a 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -36,6 +36,7 @@
 #include <iss/iss.h>
 #include <iss/llvm/vm_base.h>
 #include <util/logging.h>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -136,27 +137,21 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>
     }};
- 
+
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     /* instruction definitions */<%instructions.eachWithIndex{instr, idx -> %>
     /* instruction ${idx}: ${instr.name} */
     std::tuple<continuation_e, BasicBlock*> __${generator.functionName(instr.name)}(virt_addr_t& pc, code_word_t instr, BasicBlock* bb){
@@ -219,58 +214,6 @@ private:
         this->builder.CreateBr(bb);
         return std::make_tuple(BRANCH, nullptr);
     }    
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
@@ -282,13 +225,16 @@ template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 std::tuple<continuation_e, BasicBlock *>
@@ -309,13 +255,16 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 //            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
 //        }
 //    } else {
-        auto res = this->core.read(paddr, 4, data);
-        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
+    auto res = this->core.read(paddr, 4, data);
+    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
 //    }
     if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     // curr pc on stack
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) {
         f = &this_class::illegal_instruction;
     }
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index a6e2f64..6f688df 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -37,6 +37,7 @@
 #include <iss/tcc/vm_base.h>
 #include <util/logging.h>
 #include <sstream>
+#include <vm/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -130,34 +131,28 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    }    
+    }
 
 private:
     /****************************************************************************
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         compile_func op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
-
-    decoding_tree_node* root {nullptr};
 
     const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         /* instruction ${instr.instruction.name}, encoding '${instr.encoding}' */
         {${instr.length}, ${instr.encoding}, ${instr.mask}, &this_class::__${generator.functionName(instr.name)}},<%}%>
     }};
- 
+
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     /* instruction definitions */<%instructions.eachWithIndex{instr, idx -> %>
     /* instruction ${idx}: ${instr.name} */
     compile_ret_t __${generator.functionName(instr.name)}(virt_addr_t& pc, code_word_t instr, tu_builder& tu){
@@ -198,59 +193,6 @@ private:
         vm_impl::gen_trap_check(tu);
         return BRANCH;
     }
-    
-    //decoding functionality
-
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-    compile_func decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return nullptr;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD instr) {
@@ -262,13 +204,16 @@ template <typename ARCH> vm_impl<ARCH>::vm_impl() { this(new ARCH()); }
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 template <typename ARCH>
 std::tuple<continuation_e>
@@ -287,13 +232,16 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
 //            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
 //        }
 //    } else {
-        auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
-        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
+    auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
+    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
 //    }
     if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
     // curr pc on stack
     ++inst_cnt;
-    auto f = decode_instr(root, instr);
+    uint32_t inst_index = instr_decoder.decode_instr(instr);
+    compile_func f = nullptr;
+    if(inst_index < instr_descr.size())
+        f = instr_descr[inst_index].op;
     if (f == nullptr) {
         f = &this_class::illegal_instruction;
     }
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 00b7f4a..859c65c 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -302,7 +302,7 @@ private:
 
     //needs to be declared after instr_descr
     decoder instr_decoder;
- 
+
     /* instruction definitions */
     /* instruction 0: LUI */
     continuation_e __lui(virt_addr_t& pc, code_word_t instr, jit_holder& jh){
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index cee7dd0..c5cd06f 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -320,7 +320,7 @@ private:
         /* instruction DII, encoding '0b0000000000000000' */
         {16, 0b0000000000000000, 0b1111111111111111, &this_class::__dii},
     }};
- 
+
     //needs to be declared after instr_descr
     decoder instr_decoder;
 
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index ba61306..1969679 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -131,7 +131,7 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    }    
+    }
 
 private:
     /****************************************************************************

From 86de536c8fd176cbcfc31d2d8bb8c86f5d0f414e Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 14:35:31 +0200
Subject: [PATCH 040/100] changes jh globals to seperate riscv specifics

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 23 ++++++++++++++++++---
 src/vm/asmjit/vm_tgc5c.cpp                  | 23 ++++++++++++++++++---
 2 files changed, 40 insertions(+), 6 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 5749f29..9ad7de4 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -91,7 +91,6 @@ protected:
     using super::gen_wait;
     using super::gen_leave;
     using super::gen_sync;
-    using super::gen_set_tval;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -104,6 +103,8 @@ protected:
     void gen_instr_prologue(jit_holder& jh);
     void gen_instr_epilogue(jit_holder& jh);
     inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
+    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>> void gen_set_tval(jit_holder& jh, T new_tval) ;
+    void gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) ;
 
     template<unsigned W, typename U, typename S = typename std::make_signed<U>::type>
     inline S sext(U from) {
@@ -260,7 +261,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
-    jh.tval = get_reg_Gp(jh.cc, 64, false);
+    jh.globals["tval"] = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -283,7 +284,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, jh.tval);
+    call_enter_trap->setArg(3, jh.globals["tval"]);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
@@ -300,6 +301,22 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
 }
+template <typename ARCH>
+template <typename T, typename>
+void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
+        mov(jh.cc, jh.globals["tval"], new_tval);
+    }
+template <typename ARCH>
+void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
+    if(std::holds_alternative<x86::Gp>(_new_tval)) {
+        x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
+        if(new_tval.size() < 8)
+            new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
+        mov(jh.cc, jh.globals["tval"], new_tval);
+    } else {
+        throw std::runtime_error("Variant not supported in gen_set_tval");
+    }
+}
 
 } // namespace tgc5c
 
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 859c65c..f9d774d 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -91,7 +91,6 @@ protected:
     using super::gen_wait;
     using super::gen_leave;
     using super::gen_sync;
-    using super::gen_set_tval;
    
     using this_class = vm_impl<ARCH>;
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
@@ -104,6 +103,8 @@ protected:
     void gen_instr_prologue(jit_holder& jh);
     void gen_instr_epilogue(jit_holder& jh);
     inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
+    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>> void gen_set_tval(jit_holder& jh, T new_tval) ;
+    void gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) ;
 
     template<unsigned W, typename U, typename S = typename std::make_signed<U>::type>
     inline S sext(U from) {
@@ -4800,7 +4801,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
-    jh.tval = get_reg_Gp(jh.cc, 64, false);
+    jh.globals["tval"] = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -4823,7 +4824,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, jh.tval);
+    call_enter_trap->setArg(3, jh.globals["tval"]);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
@@ -4840,6 +4841,22 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
 }
+template <typename ARCH>
+template <typename T, typename>
+void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
+        mov(jh.cc, jh.globals["tval"], new_tval);
+    }
+template <typename ARCH>
+void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
+    if(std::holds_alternative<x86::Gp>(_new_tval)) {
+        x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
+        if(new_tval.size() < 8)
+            new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
+        mov(jh.cc, jh.globals["tval"], new_tval);
+    } else {
+        throw std::runtime_error("Variant not supported in gen_set_tval");
+    }
+}
 
 } // namespace tgc5c
 

From 0d6bf924ed7fed0b3b33cbde97b09805dae6ed0c Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 23 Jul 2024 15:45:51 +0200
Subject: [PATCH 041/100] changes jh.globals from map to vector

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 10 ++++++----
 src/vm/asmjit/vm_tgc5c.cpp                  | 10 ++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 9ad7de4..97ed953 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -96,6 +96,7 @@ protected:
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
 
     continuation_e gen_single_inst_behavior(virt_addr_t&, unsigned int &, jit_holder&) override;
+    enum globals_e {TVAL = 0, GLOBALS_SIZE};
     void gen_block_prologue(jit_holder& jh) override;
     void gen_block_epilogue(jit_holder& jh) override;
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
@@ -261,7 +262,8 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
-    jh.globals["tval"] = get_reg_Gp(jh.cc, 64, false);
+    jh.globals.resize(GLOBALS_SIZE);
+    jh.globals[TVAL] = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -284,7 +286,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, jh.globals["tval"]);
+    call_enter_trap->setArg(3, jh.globals[TVAL]);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
@@ -304,7 +306,7 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
 template <typename ARCH>
 template <typename T, typename>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
-        mov(jh.cc, jh.globals["tval"], new_tval);
+        mov(jh.cc, jh.globals[TVAL], new_tval);
     }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
@@ -312,7 +314,7 @@ void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
         x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
         if(new_tval.size() < 8)
             new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
-        mov(jh.cc, jh.globals["tval"], new_tval);
+        mov(jh.cc, jh.globals[TVAL], new_tval);
     } else {
         throw std::runtime_error("Variant not supported in gen_set_tval");
     }
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index f9d774d..fe0215c 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -96,6 +96,7 @@ protected:
     using compile_func = continuation_e (this_class::*)(virt_addr_t&, code_word_t, jit_holder&);
 
     continuation_e gen_single_inst_behavior(virt_addr_t&, unsigned int &, jit_holder&) override;
+    enum globals_e {TVAL = 0, GLOBALS_SIZE};
     void gen_block_prologue(jit_holder& jh) override;
     void gen_block_epilogue(jit_holder& jh) override;
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
@@ -4801,7 +4802,8 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
     jh.pc = load_reg_from_mem_Gp(jh, traits::PC);
     jh.next_pc = load_reg_from_mem_Gp(jh, traits::NEXT_PC);
-    jh.globals["tval"] = get_reg_Gp(jh.cc, 64, false);
+    jh.globals.resize(GLOBALS_SIZE);
+    jh.globals[TVAL] = get_reg_Gp(jh.cc, 64, false);
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
@@ -4824,7 +4826,7 @@ void vm_impl<ARCH>::gen_block_epilogue(jit_holder& jh){
     call_enter_trap->setArg(0, jh.arch_if_ptr);
     call_enter_trap->setArg(1, current_trap_state);
     call_enter_trap->setArg(2, current_pc);
-    call_enter_trap->setArg(3, jh.globals["tval"]);
+    call_enter_trap->setArg(3, jh.globals[TVAL]);
 
     x86_reg_t current_next_pc = get_reg_for(cc, traits::NEXT_PC);
     mov(cc, current_next_pc, get_ptr_for(jh, traits::NEXT_PC));
@@ -4844,7 +4846,7 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
 template <typename ARCH>
 template <typename T, typename>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
-        mov(jh.cc, jh.globals["tval"], new_tval);
+        mov(jh.cc, jh.globals[TVAL], new_tval);
     }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
@@ -4852,7 +4854,7 @@ void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
         x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
         if(new_tval.size() < 8)
             new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
-        mov(jh.cc, jh.globals["tval"], new_tval);
+        mov(jh.cc, jh.globals[TVAL], new_tval);
     } else {
         throw std::runtime_error("Variant not supported in gen_set_tval");
     }

From b1306c3a47949151e8baafba89652e8829911493 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 24 Jul 2024 08:54:37 +0200
Subject: [PATCH 042/100] improves instruction decoding by avoiding copying,
 replaces .size()

---
 src/vm/instruction_decoder.cpp | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/vm/instruction_decoder.cpp b/src/vm/instruction_decoder.cpp
index b975d81..34fbe8a 100644
--- a/src/vm/instruction_decoder.cpp
+++ b/src/vm/instruction_decoder.cpp
@@ -85,15 +85,13 @@ void decoder::populate_decoding_tree(decoding_tree_node& parent) {
 }
 uint32_t decoder::decode_instr(uint32_t word) { return _decode_instr(this->root, word); }
 uint32_t decoder::_decode_instr(decoding_tree_node const& node, uint32_t word) {
-    if(!node.children.size()) {
-        if(node.instrs.size() == 1)
-            return node.instrs[0].index;
-        for(auto instr : node.instrs) {
+    if(!node.instrs.empty()) {
+        for(auto& instr : node.instrs) {
             if((instr.mask & word) == instr.value)
                 return instr.index;
         }
-    } else {
-        for(auto child : node.children) {
+    } else if(!node.children.empty()) {
+        for(auto& child : node.children) {
             if(child.value == (node.submask & word)) {
                 return _decode_instr(child, word);
             }

From c6b99cd155877d630102edebeb8def5178913762 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 24 Jul 2024 12:28:35 +0200
Subject: [PATCH 043/100] introduces new decoder to interp backend

---
 gen_input/templates/interp/CORENAME.cpp.gtl | 93 +++++----------------
 src/vm/interp/vm_tgc5c.cpp                  |  3 +
 2 files changed, 26 insertions(+), 70 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index c9624f9..43968bf 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -35,6 +35,7 @@ def nativeTypeSize(int size){
 }
 %>
 // clang-format off
+#include <cstdint>
 #include <iss/arch/${coreDef.name.toLowerCase()}.h>
 #include <iss/debugger/gdb_session.h>
 #include <iss/debugger/server.h>
@@ -47,6 +48,8 @@ def nativeTypeSize(int size){
 #include <exception>
 #include <vector>
 #include <sstream>
+#include <vm/instruction_decoder.h>
+
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -152,25 +155,20 @@ private:
      * start opcode definitions
      ****************************************************************************/
     struct instruction_descriptor {
-        size_t length;
+        uint32_t length;
         uint32_t value;
         uint32_t mask;
         typename arch::traits<ARCH>::opcode_e op;
     };
-    struct decoding_tree_node{
-        std::vector<instruction_descriptor> instrs;
-        std::vector<decoding_tree_node*> children;
-        uint32_t submask = std::numeric_limits<uint32_t>::max();
-        uint32_t value;
-        decoding_tree_node(uint32_t value) : value(value){}
-    };
 
-    decoding_tree_node* root {nullptr};
     const std::array<instruction_descriptor, ${instructions.size()}> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */<%instructions.each{instr -> %>
         {${instr.length}, ${instr.encoding}, ${instr.mask}, arch::traits<ARCH>::opcode_e::${instr.instruction.name}},<%}%>
     }};
 
+    //needs to be declared after instr_descr
+    decoder instr_decoder;
+
     iss::status fetch_ins(virt_addr_t pc, uint8_t * data){
         if(this->core.has_mmu()) {
             auto phys_pc = this->core.virt2phys(pc);
@@ -190,58 +188,6 @@ private:
         }
         return iss::Ok;
     }
-    
-    void populate_decoding_tree(decoding_tree_node* root){
-        //create submask
-        for(auto instr: root->instrs){
-            root->submask &= instr.mask;
-        }
-        //put each instr according to submask&encoding into children
-        for(auto instr: root->instrs){
-            bool foundMatch = false;
-            for(auto child: root->children){
-                //use value as identifying trait
-                if(child->value == (instr.value&root->submask)){
-                    child->instrs.push_back(instr);
-                    foundMatch = true;
-                }
-            }
-            if(!foundMatch){
-                decoding_tree_node* child = new decoding_tree_node(instr.value&root->submask);
-                child->instrs.push_back(instr);
-                root->children.push_back(child);
-            }
-        }
-        root->instrs.clear();
-        //call populate_decoding_tree for all children
-        if(root->children.size() >1)
-            for(auto child: root->children){
-                populate_decoding_tree(child);      
-            }
-        else{
-            //sort instrs by value of the mask, this works bc we want to have the least restrictive one last
-            std::sort(root->children[0]->instrs.begin(), root->children[0]->instrs.end(), [](const instruction_descriptor& instr1, const instruction_descriptor& instr2) {
-            return instr1.mask > instr2.mask;
-            }); 
-        }
-    }
-
-    typename arch::traits<ARCH>::opcode_e  decode_instr(decoding_tree_node* node, code_word_t word){
-        if(!node->children.size()){
-            if(node->instrs.size() == 1) return node->instrs[0].op;
-            for(auto instr : node->instrs){
-                if((instr.mask&word) == instr.value) return instr.op;
-            }
-        }
-        else{
-            for(auto child : node->children){
-                if (child->value == (node->submask&word)){
-                    return decode_instr(child, word);
-                }  
-            }  
-        }
-        return arch::traits<ARCH>::opcode_e::MAX_OPCODE;
-    }
 };
 
 template <typename CODE_WORD> void debug_fn(CODE_WORD insn) {
@@ -267,13 +213,16 @@ constexpr size_t bit_count(uint32_t u) {
 
 template <typename ARCH>
 vm_impl<ARCH>::vm_impl(ARCH &core, unsigned core_id, unsigned cluster_id)
-: vm_base<ARCH>(core, core_id, cluster_id) {
-    root = new decoding_tree_node(std::numeric_limits<uint32_t>::max());
-    for(auto instr:instr_descr){
-        root->instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
+: vm_base<ARCH>(core, core_id, cluster_id)
+, instr_decoder([this]() {
+        std::vector<generic_instruction_descriptor> g_instr_descr;
+        g_instr_descr.reserve(instr_descr.size());
+        for (uint32_t i = 0; i < instr_descr.size(); ++i) {
+            generic_instruction_descriptor new_instr_descr {instr_descr[i].value, instr_descr[i].mask, i};
+            g_instr_descr.push_back(new_instr_descr);
+        }
+        return std::move(g_instr_descr);
+    }()) {}
 
 inline bool is_icount_limit_enabled(finish_cond_e cond){
     return (cond & finish_cond_e::ICOUNT_LIMIT) == finish_cond_e::ICOUNT_LIMIT;
@@ -310,9 +259,13 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
         } else {
             if (is_jump_to_self_enabled(cond) &&
                     (instr == 0x0000006f || (instr&0xffff)==0xa001)) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-            auto inst_id = decode_instr(root, instr);
+            uint32_t inst_index = instr_decoder.decode_instr(instr);
+            opcode_e inst_id = arch::traits<ARCH>::opcode_e::MAX_OPCODE;;
+            if(inst_index <instr_descr.size())
+                inst_id = instr_descr.at(instr_decoder.decode_instr(instr)).op;
+
             // pre execution stuff
-             this->core.reg.last_branch = 0;
+            this->core.reg.last_branch = 0;
             if(this->sync_exec && PRE_SYNC) this->do_sync(PRE_SYNC, static_cast<unsigned>(inst_id));
             try{
                 switch(inst_id){<%instructions.eachWithIndex{instr, idx -> %>
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 64b716e..aa930ff 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -46,6 +46,7 @@
 #include <sstream>
 #include <vm/instruction_decoder.h>
 
+
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
@@ -153,6 +154,7 @@ private:
         uint32_t mask;
         typename arch::traits<ARCH>::opcode_e op;
     };
+
     const std::array<instruction_descriptor, 87> instr_descr = {{
          /* entries are: size, valid value, valid mask, function ptr */
         {32, 0b00000000000000000000000000110111, 0b00000000000000000000000001111111, arch::traits<ARCH>::opcode_e::LUI},
@@ -243,6 +245,7 @@ private:
         {16, 0b1100000000000010, 0b1110000000000011, arch::traits<ARCH>::opcode_e::C__SWSP},
         {16, 0b0000000000000000, 0b1111111111111111, arch::traits<ARCH>::opcode_e::DII},
     }};
+
     //needs to be declared after instr_descr
     decoder instr_decoder;
 

From 5a2b96ef3e247cfa2dadca46e39a9db3576f7c7b Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Wed, 24 Jul 2024 12:20:38 +0200
Subject: [PATCH 044/100] adds logging categories for ISS

---
 src/iss/arch/riscv_hart_m_p.h  | 114 ++++++++++++++++----------------
 src/iss/arch/riscv_hart_mu_p.h | 116 ++++++++++++++++-----------------
 2 files changed, 115 insertions(+), 115 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index e45f292..ea24bb4 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -61,7 +61,7 @@
 namespace iss {
 namespace arch {
 
-template <typename BASE, features_e FEAT = FEAT_NONE> class riscv_hart_m_p : public BASE, public riscv_hart_common {
+template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT=logging::disass> class riscv_hart_m_p : public BASE, public riscv_hart_common {
 protected:
     const std::array<const char, 4> lvl = {{'U', 'S', 'H', 'M'}};
     const std::array<const char*, 16> trap_str = {{""
@@ -88,7 +88,7 @@ protected:
 
 public:
     using core = BASE;
-    using this_class = riscv_hart_m_p<BASE, FEAT>;
+    using this_class = riscv_hart_m_p<BASE, FEAT, LOGCAT>;
     using phys_addr_t = typename core::phys_addr_t;
     using reg_t = typename core::reg_t;
     using addr_t = typename core::addr_t;
@@ -275,7 +275,7 @@ public:
     void set_mhartid(reg_t mhartid) { mhartid_reg = mhartid; };
 
     void disass_output(uint64_t pc, const std::string instr) override {
-        CLOG(INFO, disass) << fmt::format("0x{:016x}    {:40} [s:0x{:x};c:{}]", pc, instr, (reg_t)state.mstatus,
+        NSCLOG(INFO, LOGCAT) << fmt::format("0x{:016x}    {:40} [s:0x{:x};c:{}]", pc, instr, (reg_t)state.mstatus,
                                           this->reg.icount + cycle_offset);
     };
 
@@ -290,7 +290,7 @@ public:
 protected:
     struct riscv_instrumentation_if : public iss::instrumentation_if {
 
-        riscv_instrumentation_if(riscv_hart_m_p<BASE, FEAT>& arch)
+        riscv_instrumentation_if(riscv_hart_m_p<BASE, FEAT, LOGCAT>& arch)
         : arch(arch) {}
         /**
          * get the name of this architecture
@@ -321,7 +321,7 @@ protected:
 
         std::unordered_map<std::string, uint64_t> get_symbol_table(std::string name) override { return arch.get_sym_table(name); }
 
-        riscv_hart_m_p<BASE, FEAT>& arch;
+        riscv_hart_m_p<BASE, FEAT, LOGCAT>& arch;
     };
 
     friend struct riscv_instrumentation_if;
@@ -432,8 +432,8 @@ protected:
     std::function<mem_write_f> hart_mem_wr_delegate;
 };
 
-template <typename BASE, features_e FEAT>
-riscv_hart_m_p<BASE, FEAT>::riscv_hart_m_p(feature_config cfg)
+template <typename BASE, features_e FEAT, typename LOGCAT>
+riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
 : state()
 , instr_if(*this)
 , cfg(cfg) {
@@ -564,7 +564,7 @@ riscv_hart_m_p<BASE, FEAT>::riscv_hart_m_p(feature_config cfg)
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
 }
 
-template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT>::load_file(std::string name, int type) {
+template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
     get_sym_table(name);
     try {
         tohost = symbol_table.at("tohost");
@@ -618,8 +618,8 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
     throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
 }
 
-template <typename BASE, features_e FEAT>
-inline void riscv_hart_m_p<BASE, FEAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+inline void riscv_hart_m_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
                                                          std::function<mem_write_f> wr_fn) {
     std::tuple<uint64_t, uint64_t> entry{base, size};
     auto it = std::upper_bound(
@@ -631,8 +631,8 @@ inline void riscv_hart_m_p<BASE, FEAT>::insert_mem_range(uint64_t base, uint64_t
     memfn_write.insert(std::begin(memfn_write) + idx, wr_fn);
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
                                              const unsigned length, uint8_t* const data) {
 #ifndef NDEBUG
     if(access && iss::access_type::DEBUG) {
@@ -715,8 +715,8 @@ iss::status riscv_hart_m_p<BASE, FEAT>::read(const address_type type, const acce
     }
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
                                               const unsigned length, const uint8_t* const data) {
 #ifndef NDEBUG
     const char* prefix = (access && iss::access_type::DEBUG) ? "debug " : "";
@@ -848,7 +848,7 @@ iss::status riscv_hart_m_p<BASE, FEAT>::write(const address_type type, const acc
     }
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_csr(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -860,7 +860,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_csr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -874,22 +874,22 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_csr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_null(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_csr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_cycle(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
     auto cycle_val = this->reg.icount + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
@@ -899,7 +899,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_cycle(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         mcycle_csr = static_cast<uint64_t>(val);
     } else {
@@ -913,7 +913,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_instret(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
     if((addr & 0xff) == (minstret & 0xff)) {
         val = static_cast<reg_t>(this->reg.instret);
     } else if((addr & 0xff) == (minstreth & 0xff)) {
@@ -922,7 +922,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_instret(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         this->reg.instret = static_cast<uint64_t>(val);
     } else {
@@ -936,7 +936,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_time(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
     uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
@@ -948,23 +948,23 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_tvec(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
     val = FEAT & features_e::FEAT_CLIC ? csr[addr] : csr[addr] & ~2;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_status(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
     val = state.mstatus & hart_state_type::get_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_status(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
     state.write_mstatus(val);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_cause(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         val = csr[addr] & ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         val |= clic_mprev_lvl << 16;
@@ -975,7 +975,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_cause(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         auto mask = ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         csr[addr] = (val & mask) | (csr[addr] & ~mask);
@@ -989,36 +989,36 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_hartid(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
     val = mhartid_reg;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_ie(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask();
     val = csr[mie] & mask;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_ie(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
     auto mask = get_irq_mask();
     csr[mie] = (csr[mie] & ~mask) | (val & mask);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_ip(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask();
     val = csr[mip] & mask;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_epc(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
     csr[addr] = val & get_pc_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1029,51 +1029,51 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_dpc_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::read_intstatus(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
     val = (clic_mact_lvl & 0xff) << 24;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_intthresh(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_m_p<BASE, FEAT>::write_xtvt(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
     csr[addr] = val & ~0x3fULL;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::read_mem(phys_addr_t paddr, unsigned length, uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_mem(phys_addr_t paddr, unsigned length, uint8_t* const data) {
     switch(paddr.val) {
     default: {
         for(auto offs = 0U; offs < length; ++offs) {
@@ -1084,8 +1084,8 @@ iss::status riscv_hart_m_p<BASE, FEAT>::read_mem(phys_addr_t paddr, unsigned len
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::write_mem(phys_addr_t paddr, unsigned length, const uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_mem(phys_addr_t paddr, unsigned length, const uint8_t* const data) {
     switch(paddr.val) {
     // TODO remove UART, Peripherals should not be part of the ISS
     case 0xFFFF0000: // UART0 base, TXFIFO reg
@@ -1143,8 +1143,8 @@ iss::status riscv_hart_m_p<BASE, FEAT>::write_mem(phys_addr_t paddr, unsigned le
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::read_clic(uint64_t addr, unsigned length, uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_clic(uint64_t addr, unsigned length, uint8_t* const data) {
     if(addr == cfg.clic_base) { // cliccfg
         *data = clic_cfg_reg;
         for(auto i = 1; i < length; ++i)
@@ -1163,8 +1163,8 @@ iss::status riscv_hart_m_p<BASE, FEAT>::read_clic(uint64_t addr, unsigned length
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_m_p<BASE, FEAT>::write_clic(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_clic(uint64_t addr, unsigned length, const uint8_t* const data) {
     if(addr == cfg.clic_base) { // cliccfg
         clic_cfg_reg = (clic_cfg_reg & ~0x1e) | (*data & 0x1e);
     } else if(addr >= (cfg.clic_base + 0x40) && (addr + length) <= (cfg.clic_base + 0x40 + cfg.clic_num_trigger * 4)) { // clicinttrig
@@ -1179,12 +1179,12 @@ iss::status riscv_hart_m_p<BASE, FEAT>::write_clic(uint64_t addr, unsigned lengt
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> inline void riscv_hart_m_p<BASE, FEAT>::reset(uint64_t address) {
+template <typename BASE, features_e FEAT, typename LOGCAT> inline void riscv_hart_m_p<BASE, FEAT, LOGCAT>::reset(uint64_t address) {
     BASE::reset(address);
     state.mstatus = hart_state_type::mstatus_reset_val;
 }
 
-template <typename BASE, features_e FEAT> void riscv_hart_m_p<BASE, FEAT>::check_interrupt() {
+template <typename BASE, features_e FEAT, typename LOGCAT> void riscv_hart_m_p<BASE, FEAT, LOGCAT>::check_interrupt() {
     // TODO: Implement CLIC functionality
     // auto ideleg = csr[mideleg];
     // Multiple simultaneous interrupts and traps at the same privilege level are
@@ -1207,7 +1207,7 @@ template <typename BASE, features_e FEAT> void riscv_hart_m_p<BASE, FEAT>::check
     }
 }
 
-template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t tval) {
+template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t tval) {
     // flags are ACTIVE[31:31], CAUSE[30:16], TRAPID[15:0]
     // calculate and write mcause val
     auto const trap_id = bit_sub<0, 16>(flags);
@@ -1260,7 +1260,7 @@ template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::e
 #else
                     sprintf(buffer.data(), "0x%016lx", addr);
 #endif
-                    CLOG(INFO, disass) << "Semihosting call at address " << buffer.data() << " occurred ";
+                    NSCLOG(INFO, LOGCAT) << "Semihosting call at address " << buffer.data() << " occurred ";
 
                     semihosting_cb(this, &(this->reg.X10) /*a0*/, &(this->reg.X11) /*a1*/);
                     return this->reg.NEXT_PC;
@@ -1316,18 +1316,18 @@ template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::e
     sprintf(buffer.data(), "0x%016lx", addr);
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
-        CLOG(INFO, disass) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
+        NSCLOG(INFO, LOGCAT) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
                            << cause << ")"
                            << " at address " << buffer.data() << " occurred";
     return this->reg.NEXT_PC;
 }
 
-template <typename BASE, features_e FEAT> uint64_t riscv_hart_m_p<BASE, FEAT>::leave_trap(uint64_t flags) {
+template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::leave_trap(uint64_t flags) {
     state.mstatus.MIE = state.mstatus.MPIE;
     state.mstatus.MPIE = 1;
     // sets the pc to the value stored in the x epc register.
     this->reg.NEXT_PC = csr[mepc] & get_pc_mask();
-    CLOG(INFO, disass) << "Executing xRET";
+    NSCLOG(INFO, LOGCAT) << "Executing xRET";
     check_interrupt();
     this->reg.trap_state = this->reg.pending_trap;
     return this->reg.NEXT_PC;
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 345ea27..fc27466 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -60,7 +60,7 @@
 namespace iss {
 namespace arch {
 
-template <typename BASE, features_e FEAT = FEAT_NONE> class riscv_hart_mu_p : public BASE, public riscv_hart_common {
+template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT=logging::disass> class riscv_hart_mu_p : public BASE, public riscv_hart_common {
 protected:
     const std::array<const char, 4> lvl = {{'U', 'S', 'H', 'M'}};
     const std::array<const char*, 16> trap_str = {{""
@@ -87,7 +87,7 @@ protected:
 
 public:
     using core = BASE;
-    using this_class = riscv_hart_mu_p<BASE, FEAT>;
+    using this_class = riscv_hart_mu_p<BASE, FEAT, LOGCAT>;
     using phys_addr_t = typename core::phys_addr_t;
     using reg_t = typename core::reg_t;
     using addr_t = typename core::addr_t;
@@ -316,7 +316,7 @@ public:
 protected:
     struct riscv_instrumentation_if : public iss::instrumentation_if {
 
-        riscv_instrumentation_if(riscv_hart_mu_p<BASE, FEAT>& arch)
+        riscv_instrumentation_if(riscv_hart_mu_p<BASE, FEAT, LOGCAT>& arch)
         : arch(arch) {}
         /**
          * get the name of this architecture
@@ -347,7 +347,7 @@ protected:
 
         std::unordered_map<std::string, uint64_t> get_symbol_table(std::string name) override { return arch.get_sym_table(name); }
 
-        riscv_hart_mu_p<BASE, FEAT>& arch;
+        riscv_hart_mu_p<BASE, FEAT, LOGCAT>& arch;
     };
 
     friend struct riscv_instrumentation_if;
@@ -461,8 +461,8 @@ protected:
     std::function<mem_write_f> hart_mem_wr_delegate;
 };
 
-template <typename BASE, features_e FEAT>
-riscv_hart_mu_p<BASE, FEAT>::riscv_hart_mu_p(feature_config cfg)
+template <typename BASE, features_e FEAT, typename LOGCAT>
+riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
 : state()
 , instr_if(*this)
 , cfg(cfg) {
@@ -641,7 +641,7 @@ riscv_hart_mu_p<BASE, FEAT>::riscv_hart_mu_p(feature_config cfg)
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
 }
 
-template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT>::load_file(std::string name, int type) {
+template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
     FILE* fp = fopen(name.c_str(), "r");
     if(fp) {
         std::array<char, 5> buf;
@@ -709,8 +709,8 @@ template <typename BASE, features_e FEAT> std::pair<uint64_t, bool> riscv_hart_m
     throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
 }
 
-template <typename BASE, features_e FEAT>
-inline void riscv_hart_mu_p<BASE, FEAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+inline void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
                                                           std::function<mem_write_f> wr_fn) {
     std::tuple<uint64_t, uint64_t> entry{base, size};
     auto it = std::upper_bound(
@@ -722,13 +722,13 @@ inline void riscv_hart_mu_p<BASE, FEAT>::insert_mem_range(uint64_t base, uint64_
     memfn_write.insert(std::begin(memfn_write) + idx, wr_fn);
 }
 
-template <typename BASE, features_e FEAT> inline iss::status riscv_hart_mu_p<BASE, FEAT>::write_pmpcfg_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> inline iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_pmpcfg_reg(unsigned addr, reg_t val) {
     csr[addr] = val & 0x9f9f9f9f;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-bool riscv_hart_mu_p<BASE, FEAT>::pmp_check(const access_type type, const uint64_t addr, const unsigned len) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+bool riscv_hart_mu_p<BASE, FEAT, LOGCAT>::pmp_check(const access_type type, const uint64_t addr, const unsigned len) {
     constexpr auto PMP_SHIFT = 2U;
     constexpr auto PMP_R = 0x1U;
     constexpr auto PMP_W = 0x2U;
@@ -808,8 +808,8 @@ bool riscv_hart_mu_p<BASE, FEAT>::pmp_check(const access_type type, const uint64
     return !any_active || this->reg.PRIV == PRIV_M;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
                                               const unsigned length, uint8_t* const data) {
 #ifndef NDEBUG
     if(access && iss::access_type::DEBUG) {
@@ -901,8 +901,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::read(const address_type type, const acc
     }
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
                                                const unsigned length, const uint8_t* const data) {
 #ifndef NDEBUG
     const char* prefix = (access && iss::access_type::DEBUG) ? "debug " : "";
@@ -1043,7 +1043,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::write(const address_type type, const ac
     }
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_csr(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -1055,7 +1055,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_csr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -1069,22 +1069,22 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_csr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_null(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_csr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_cycle(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
     auto cycle_val = this->reg.icount + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
@@ -1094,7 +1094,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_cycle(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         mcycle_csr = static_cast<uint64_t>(val);
     } else {
@@ -1108,7 +1108,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_instret(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
     if((addr & 0xff) == (minstret & 0xff)) {
         val = static_cast<reg_t>(this->reg.instret);
     } else if((addr & 0xff) == (minstreth & 0xff)) {
@@ -1117,7 +1117,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_instret(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         this->reg.instret = static_cast<uint64_t>(val);
     } else {
@@ -1131,7 +1131,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_time(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
     uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
@@ -1143,22 +1143,22 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_tvec(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
     val = FEAT & features_e::FEAT_CLIC ? csr[addr] : csr[addr] & ~2;
     return iss::Ok;
 }
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_status(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
     val = state.mstatus & hart_state_type::get_mask((addr >> 8) & 0x3);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_status(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
     state.write_mstatus(val, (addr >> 8) & 0x3);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_cause(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         val = csr[addr] & ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         auto mode = (addr >> 8) & 0x3;
@@ -1178,7 +1178,7 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_cause(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         auto mask = ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         csr[addr] = (val & mask) | (csr[addr] & ~mask);
@@ -1201,12 +1201,12 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_hartid(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
     val = mhartid_reg;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_ie(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     val = csr[mie] & mask;
     if(this->reg.PRIV != 3)
@@ -1214,14 +1214,14 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_ie(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     csr[mie] = (csr[mie] & ~mask) | (val & mask);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_ip(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     val = csr[mip] & mask;
     if(this->reg.PRIV != 3)
@@ -1229,24 +1229,24 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_ideleg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ideleg(unsigned addr, reg_t val) {
     auto mask = 0b000100010001; // only U mode supported
     csr[mideleg] = (csr[mideleg] & ~mask) | (val & mask);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_edeleg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_edeleg(unsigned addr, reg_t val) {
     auto mask = 0b1011001111110111; // bit 14/10 (reserved), bit 11 (Env call), and 3 (break) are hardwired to 0
     csr[medeleg] = (csr[medeleg] & ~mask) | (val & mask);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_epc(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
     csr[addr] = val & get_pc_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1257,35 +1257,35 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_dpc_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::read_intstatus(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
     auto mode = (addr >> 8) & 0x3;
     val = clic_uact_lvl & 0xff;
     if(mode == 0x3)
@@ -1293,18 +1293,18 @@ template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_intthresh(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> iss::status riscv_hart_mu_p<BASE, FEAT>::write_xtvt(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
     csr[addr] = val & ~0x3fULL;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::read_mem(phys_addr_t paddr, unsigned length, uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_mem(phys_addr_t paddr, unsigned length, uint8_t* const data) {
     switch(paddr.val) {
     default: {
         for(auto offs = 0U; offs < length; ++offs) {
@@ -1315,8 +1315,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::read_mem(phys_addr_t paddr, unsigned le
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::write_mem(phys_addr_t paddr, unsigned length, const uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_mem(phys_addr_t paddr, unsigned length, const uint8_t* const data) {
     switch(paddr.val) {
     // TODO remove UART, Peripherals should not be part of the ISS
     case 0xFFFF0000: // UART0 base, TXFIFO reg
@@ -1377,8 +1377,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::write_mem(phys_addr_t paddr, unsigned l
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::read_clic(uint64_t addr, unsigned length, uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_clic(uint64_t addr, unsigned length, uint8_t* const data) {
     if(addr == cfg.clic_base) { // cliccfg
         *data = clic_cfg_reg;
         for(auto i = 1; i < length; ++i)
@@ -1397,8 +1397,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::read_clic(uint64_t addr, unsigned lengt
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT>
-iss::status riscv_hart_mu_p<BASE, FEAT>::write_clic(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_clic(uint64_t addr, unsigned length, const uint8_t* const data) {
     if(addr == cfg.clic_base) { // cliccfg
         clic_cfg_reg = (clic_cfg_reg & ~0x1e) | (*data & 0x1e);
     } else if(addr >= (cfg.clic_base + 0x40) && (addr + length) <= (cfg.clic_base + 0x40 + cfg.clic_num_trigger * 4)) { // clicinttrig
@@ -1413,12 +1413,12 @@ iss::status riscv_hart_mu_p<BASE, FEAT>::write_clic(uint64_t addr, unsigned leng
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT> inline void riscv_hart_mu_p<BASE, FEAT>::reset(uint64_t address) {
+template <typename BASE, features_e FEAT, typename LOGCAT> inline void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::reset(uint64_t address) {
     BASE::reset(address);
     state.mstatus = hart_state_type::mstatus_reset_val;
 }
 
-template <typename BASE, features_e FEAT> void riscv_hart_mu_p<BASE, FEAT>::check_interrupt() {
+template <typename BASE, features_e FEAT, typename LOGCAT> void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::check_interrupt() {
     // TODO: Implement CLIC functionality
     auto ideleg = csr[mideleg];
     // Multiple simultaneous interrupts and traps at the same privilege level are
@@ -1441,7 +1441,7 @@ template <typename BASE, features_e FEAT> void riscv_hart_mu_p<BASE, FEAT>::chec
     }
 }
 
-template <typename BASE, features_e FEAT> uint64_t riscv_hart_mu_p<BASE, FEAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t instr) {
+template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t instr) {
     // flags are ACTIVE[31:31], CAUSE[30:16], TRAPID[15:0]
     // calculate and write mcause val
     if(flags == std::numeric_limits<uint64_t>::max())
@@ -1575,7 +1575,7 @@ template <typename BASE, features_e FEAT> uint64_t riscv_hart_mu_p<BASE, FEAT>::
     return this->reg.NEXT_PC;
 }
 
-template <typename BASE, features_e FEAT> uint64_t riscv_hart_mu_p<BASE, FEAT>::leave_trap(uint64_t flags) {
+template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::leave_trap(uint64_t flags) {
     auto cur_priv = this->reg.PRIV;
     auto inst_priv = (flags & 0x3) ? 3 : 0;
     if(inst_priv > cur_priv) {

From e87b7d5fd00559b1023856bb8ca56edac8077c99 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Wed, 24 Jul 2024 14:48:50 +0200
Subject: [PATCH 045/100] applies clang-format

---
 src/iss/arch/riscv_hart_m_p.h  | 109 ++++++++++++++++++++------------
 src/iss/arch/riscv_hart_mu_p.h | 112 +++++++++++++++++++++------------
 2 files changed, 143 insertions(+), 78 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index ea24bb4..30c15e4 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -61,7 +61,8 @@
 namespace iss {
 namespace arch {
 
-template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT=logging::disass> class riscv_hart_m_p : public BASE, public riscv_hart_common {
+template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT = logging::disass>
+class riscv_hart_m_p : public BASE, public riscv_hart_common {
 protected:
     const std::array<const char, 4> lvl = {{'U', 'S', 'H', 'M'}};
     const std::array<const char*, 16> trap_str = {{""
@@ -276,7 +277,7 @@ public:
 
     void disass_output(uint64_t pc, const std::string instr) override {
         NSCLOG(INFO, LOGCAT) << fmt::format("0x{:016x}    {:40} [s:0x{:x};c:{}]", pc, instr, (reg_t)state.mstatus,
-                                          this->reg.icount + cycle_offset);
+                                            this->reg.icount + cycle_offset);
     };
 
     iss::instrumentation_if* get_instrumentation_if() override { return &instr_if; }
@@ -564,7 +565,8 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
     get_sym_table(name);
     try {
         tohost = symbol_table.at("tohost");
@@ -620,7 +622,7 @@ template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, b
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 inline void riscv_hart_m_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
-                                                         std::function<mem_write_f> wr_fn) {
+                                                                 std::function<mem_write_f> wr_fn) {
     std::tuple<uint64_t, uint64_t> entry{base, size};
     auto it = std::upper_bound(
         memfn_range.begin(), memfn_range.end(), entry,
@@ -632,8 +634,8 @@ inline void riscv_hart_m_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base,
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
-                                             const unsigned length, uint8_t* const data) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space,
+                                                     const uint64_t addr, const unsigned length, uint8_t* const data) {
 #ifndef NDEBUG
     if(access && iss::access_type::DEBUG) {
         CPPLOG(TRACEALL) << "debug read of " << length << " bytes @addr 0x" << std::hex << addr;
@@ -716,8 +718,8 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
-                                              const unsigned length, const uint8_t* const data) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space,
+                                                      const uint64_t addr, const unsigned length, const uint8_t* const data) {
 #ifndef NDEBUG
     const char* prefix = (access && iss::access_type::DEBUG) ? "debug " : "";
     switch(length) {
@@ -848,7 +850,8 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
     }
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -860,7 +863,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -874,22 +878,26 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
     auto cycle_val = this->reg.icount + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
@@ -899,7 +907,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         mcycle_csr = static_cast<uint64_t>(val);
     } else {
@@ -913,7 +922,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
     if((addr & 0xff) == (minstret & 0xff)) {
         val = static_cast<reg_t>(this->reg.instret);
     } else if((addr & 0xff) == (minstreth & 0xff)) {
@@ -922,7 +932,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         this->reg.instret = static_cast<uint64_t>(val);
     } else {
@@ -936,7 +947,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
     uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
@@ -948,23 +960,27 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
     val = FEAT & features_e::FEAT_CLIC ? csr[addr] : csr[addr] & ~2;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
     val = state.mstatus & hart_state_type::get_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
     state.write_mstatus(val);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         val = csr[addr] & ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         val |= clic_mprev_lvl << 16;
@@ -975,7 +991,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         auto mask = ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         csr[addr] = (val & mask) | (csr[addr] & ~mask);
@@ -989,36 +1006,42 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
     val = mhartid_reg;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask();
     val = csr[mie] & mask;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
     auto mask = get_irq_mask();
     csr[mie] = (csr[mie] & ~mask) | (val & mask);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask();
     val = csr[mip] & mask;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
     csr[addr] = val & get_pc_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1029,45 +1052,52 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
     val = (clic_mact_lvl & 0xff) << 24;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
     csr[addr] = val & ~0x3fULL;
     return iss::Ok;
 }
@@ -1207,7 +1237,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> void riscv_hart_m_p<B
     }
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t tval) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t tval) {
     // flags are ACTIVE[31:31], CAUSE[30:16], TRAPID[15:0]
     // calculate and write mcause val
     auto const trap_id = bit_sub<0, 16>(flags);
@@ -1317,8 +1348,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_m
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
         NSCLOG(INFO, LOGCAT) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                           << cause << ")"
-                           << " at address " << buffer.data() << " occurred";
+                             << cause << ")"
+                             << " at address " << buffer.data() << " occurred";
     return this->reg.NEXT_PC;
 }
 
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index fc27466..09a213b 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -60,7 +60,8 @@
 namespace iss {
 namespace arch {
 
-template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT=logging::disass> class riscv_hart_mu_p : public BASE, public riscv_hart_common {
+template <typename BASE, features_e FEAT = FEAT_NONE, typename LOGCAT = logging::disass>
+class riscv_hart_mu_p : public BASE, public riscv_hart_common {
 protected:
     const std::array<const char, 4> lvl = {{'U', 'S', 'H', 'M'}};
     const std::array<const char*, 16> trap_str = {{""
@@ -641,7 +642,8 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
     FILE* fp = fopen(name.c_str(), "r");
     if(fp) {
         std::array<char, 5> buf;
@@ -711,7 +713,7 @@ template <typename BASE, features_e FEAT, typename LOGCAT> std::pair<uint64_t, b
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 inline void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base, uint64_t size, std::function<mem_read_f> rd_f,
-                                                          std::function<mem_write_f> wr_fn) {
+                                                                  std::function<mem_write_f> wr_fn) {
     std::tuple<uint64_t, uint64_t> entry{base, size};
     auto it = std::upper_bound(
         memfn_range.begin(), memfn_range.end(), entry,
@@ -722,7 +724,8 @@ inline void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base,
     memfn_write.insert(std::begin(memfn_write) + idx, wr_fn);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> inline iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_pmpcfg_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+inline iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_pmpcfg_reg(unsigned addr, reg_t val) {
     csr[addr] = val & 0x9f9f9f9f;
     return iss::Ok;
 }
@@ -809,8 +812,8 @@ bool riscv_hart_mu_p<BASE, FEAT, LOGCAT>::pmp_check(const access_type type, cons
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
-                                              const unsigned length, uint8_t* const data) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, const access_type access, const uint32_t space,
+                                                      const uint64_t addr, const unsigned length, uint8_t* const data) {
 #ifndef NDEBUG
     if(access && iss::access_type::DEBUG) {
         CPPLOG(TRACEALL) << "debug read of " << length << " bytes @addr 0x" << std::hex << addr;
@@ -902,8 +905,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, c
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space, const uint64_t addr,
-                                               const unsigned length, const uint8_t* const data) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type, const access_type access, const uint32_t space,
+                                                       const uint64_t addr, const unsigned length, const uint8_t* const data) {
 #ifndef NDEBUG
     const char* prefix = (access && iss::access_type::DEBUG) ? "debug " : "";
     switch(length) {
@@ -1043,7 +1046,8 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type,
     }
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr(unsigned addr, reg_t& val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -1055,7 +1059,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t val) {
     if(addr >= csr.size())
         return iss::Err;
     auto req_priv_lvl = (addr >> 8) & 0x3;
@@ -1069,22 +1074,26 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
     auto cycle_val = this->reg.icount + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
@@ -1094,7 +1103,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         mcycle_csr = static_cast<uint64_t>(val);
     } else {
@@ -1108,7 +1118,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_instret(unsigned addr, reg_t& val) {
     if((addr & 0xff) == (minstret & 0xff)) {
         val = static_cast<reg_t>(this->reg.instret);
     } else if((addr & 0xff) == (minstreth & 0xff)) {
@@ -1117,7 +1128,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg_t val) {
     if(sizeof(typename traits<BASE>::reg_t) != 4) {
         this->reg.instret = static_cast<uint64_t>(val);
     } else {
@@ -1131,7 +1143,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
     uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
@@ -1143,22 +1156,26 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t& val) {
     val = FEAT & features_e::FEAT_CLIC ? csr[addr] : csr[addr] & ~2;
     return iss::Ok;
 }
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
     val = state.mstatus & hart_state_type::get_mask((addr >> 8) & 0x3);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_status(unsigned addr, reg_t val) {
     state.write_mstatus(val, (addr >> 8) & 0x3);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cause(unsigned addr, reg_t& val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         val = csr[addr] & ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         auto mode = (addr >> 8) & 0x3;
@@ -1178,7 +1195,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cause(unsigned addr, reg_t val) {
     if((FEAT & features_e::FEAT_CLIC) && (csr[mtvec] & 0x3) == 3) {
         auto mask = ((1UL << (traits<BASE>::XLEN - 1)) | (mcause_max_irq - 1) | (0xfUL << 16));
         csr[addr] = (val & mask) | (csr[addr] & ~mask);
@@ -1201,12 +1219,14 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_hartid(unsigned addr, reg_t& val) {
     val = mhartid_reg;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ie(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     val = csr[mie] & mask;
     if(this->reg.PRIV != 3)
@@ -1214,14 +1234,16 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ie(unsigned addr, reg_t val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     csr[mie] = (csr[mie] & ~mask) | (val & mask);
     check_interrupt();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_ip(unsigned addr, reg_t& val) {
     auto mask = get_irq_mask((addr >> 8) & 0x3);
     val = csr[mip] & mask;
     if(this->reg.PRIV != 3)
@@ -1229,24 +1251,28 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ideleg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_ideleg(unsigned addr, reg_t val) {
     auto mask = 0b000100010001; // only U mode supported
     csr[mideleg] = (csr[mideleg] & ~mask) | (val & mask);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_edeleg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_edeleg(unsigned addr, reg_t val) {
     auto mask = 0b1011001111110111; // bit 14/10 (reserved), bit 11 (Env call), and 3 (break) are hardwired to 0
     csr[medeleg] = (csr[medeleg] & ~mask) | (val & mask);
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t val) {
     csr[addr] = val & get_pc_mask();
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1257,35 +1283,40 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, reg_t& val) {
     auto mode = (addr >> 8) & 0x3;
     val = clic_uact_lvl & 0xff;
     if(mode == 0x3)
@@ -1293,12 +1324,14 @@ template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_har
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;
     return iss::Ok;
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_xtvt(unsigned addr, reg_t val) {
     csr[addr] = val & ~0x3fULL;
     return iss::Ok;
 }
@@ -1441,7 +1474,8 @@ template <typename BASE, features_e FEAT, typename LOGCAT> void riscv_hart_mu_p<
     }
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT> uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t instr) {
+template <typename BASE, features_e FEAT, typename LOGCAT>
+uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t addr, uint64_t instr) {
     // flags are ACTIVE[31:31], CAUSE[30:16], TRAPID[15:0]
     // calculate and write mcause val
     if(flags == std::numeric_limits<uint64_t>::max())

From 72b11beac51606ed547000cfce962d1c12fe30cf Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 25 Jul 2024 10:13:10 +0200
Subject: [PATCH 046/100] moves decoder to dbt-rise-core

---
 CMakeLists.txt                              |   1 -
 gen_input/templates/asmjit/CORENAME.cpp.gtl |   2 +-
 gen_input/templates/interp/CORENAME.cpp.gtl |   2 +-
 gen_input/templates/llvm/CORENAME.cpp.gtl   |   2 +-
 gen_input/templates/tcc/CORENAME.cpp.gtl    |   2 +-
 src/vm/asmjit/vm_tgc5c.cpp                  |   2 +-
 src/vm/instruction_decoder.cpp              | 101 --------------------
 src/vm/instruction_decoder.h                |  63 ------------
 src/vm/interp/vm_tgc5c.cpp                  |   2 +-
 src/vm/llvm/vm_tgc5c.cpp                    |   2 +-
 src/vm/tcc/vm_tgc5c.cpp                     |   2 +-
 11 files changed, 8 insertions(+), 173 deletions(-)
 delete mode 100644 src/vm/instruction_decoder.cpp
 delete mode 100644 src/vm/instruction_decoder.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b8dd450..2a46f47 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,7 +20,6 @@ set(LIB_SOURCES
     src/iss/arch/tgc5c.cpp
     src/vm/interp/vm_tgc5c.cpp
     src/vm/fp_functions.cpp
-    src/vm/instruction_decoder.cpp
     src/iss/semihosting/semihosting.cpp
 )
 
diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 97ed953..245727b 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -37,7 +37,7 @@
 #include <iss/asmjit/vm_base.h>
 #include <asmjit/asmjit.h>
 #include <util/logging.h>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 43968bf..6804f57 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -48,7 +48,7 @@ def nativeTypeSize(int size){
 #include <exception>
 #include <vector>
 #include <sstream>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 
 #ifndef FMT_HEADER_ONLY
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 517253a..a98b832 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -36,7 +36,7 @@
 #include <iss/iss.h>
 #include <iss/llvm/vm_base.h>
 #include <util/logging.h>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 6f688df..e6250e4 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -37,7 +37,7 @@
 #include <iss/tcc/vm_base.h>
 #include <util/logging.h>
 #include <sstream>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index fe0215c..7f0729a 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -37,7 +37,7 @@
 #include <iss/asmjit/vm_base.h>
 #include <asmjit/asmjit.h>
 #include <util/logging.h>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
diff --git a/src/vm/instruction_decoder.cpp b/src/vm/instruction_decoder.cpp
deleted file mode 100644
index 34fbe8a..0000000
--- a/src/vm/instruction_decoder.cpp
+++ /dev/null
@@ -1,101 +0,0 @@
-/*******************************************************************************
- * Copyright (C) 2024 MINRES Technologies GmbH
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Contributors:
- *       alex@minres.com - initial implementation
- ******************************************************************************/
-
-#include <algorithm>
-#include <cassert>
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <numeric>
-#include <vector>
-#include <vm/instruction_decoder.h>
-
-decoder::decoder(std::vector<generic_instruction_descriptor> instr_list) {
-    for(auto instr : instr_list) {
-        root.instrs.push_back(instr);
-    }
-    populate_decoding_tree(root);
-}
-
-void decoder::populate_decoding_tree(decoding_tree_node& parent) {
-    // create submask
-    parent.submask =
-        std::accumulate(parent.instrs.begin(), parent.instrs.end(), std::numeric_limits<uint32_t>::max(),
-                        [](int current_submask, const generic_instruction_descriptor& instr) { return current_submask & instr.mask; });
-    //  put each instr according to submask&encoding into children
-    for(auto instr : parent.instrs) {
-        bool foundMatch = false;
-        for(auto& child : parent.children) {
-            // use value as identifying trait
-            if(child.value == (instr.value & parent.submask)) {
-                child.instrs.push_back(instr);
-                foundMatch = true;
-            }
-        }
-        if(!foundMatch) {
-            decoding_tree_node child = decoding_tree_node(instr.value & parent.submask);
-            child.instrs.push_back(instr);
-            parent.children.push_back(child);
-        }
-    }
-    parent.instrs.clear();
-    // call populate_decoding_tree for all children
-    if(parent.children.size() > 1)
-        for(auto& child : parent.children) {
-            populate_decoding_tree(child);
-        }
-    else {
-        // sort instrs by value of the mask, so we have the least restrictive mask last
-        std::sort(parent.children[0].instrs.begin(), parent.children[0].instrs.end(),
-                  [](const generic_instruction_descriptor& instr1, const generic_instruction_descriptor& instr2) {
-                      return instr1.mask > instr2.mask;
-                  });
-    }
-}
-uint32_t decoder::decode_instr(uint32_t word) { return _decode_instr(this->root, word); }
-uint32_t decoder::_decode_instr(decoding_tree_node const& node, uint32_t word) {
-    if(!node.instrs.empty()) {
-        for(auto& instr : node.instrs) {
-            if((instr.mask & word) == instr.value)
-                return instr.index;
-        }
-    } else if(!node.children.empty()) {
-        for(auto& child : node.children) {
-            if(child.value == (node.submask & word)) {
-                return _decode_instr(child, word);
-            }
-        }
-    }
-    return std::numeric_limits<uint32_t>::max();
-}
diff --git a/src/vm/instruction_decoder.h b/src/vm/instruction_decoder.h
deleted file mode 100644
index c1e8aac..0000000
--- a/src/vm/instruction_decoder.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*******************************************************************************
- * Copyright (C) 2024 MINRES Technologies GmbH
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- * 1. Redistributions of source code must retain the above copyright notice,
- *    this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright notice,
- *    this list of conditions and the following disclaimer in the documentation
- *    and/or other materials provided with the distribution.
- *
- * 3. Neither the name of the copyright holder nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- *
- * Contributors:
- *       alex@minres.com - initial implementation
- ******************************************************************************/
-
-#include <cstddef>
-#include <cstdint>
-#include <limits>
-#include <vector>
-
-struct generic_instruction_descriptor {
-    uint32_t value;
-    uint32_t mask;
-    uint32_t index;
-};
-
-struct decoding_tree_node {
-    std::vector<generic_instruction_descriptor> instrs;
-    std::vector<decoding_tree_node> children;
-    uint32_t submask = std::numeric_limits<uint32_t>::max();
-    uint32_t value;
-    decoding_tree_node(uint32_t value)
-    : value(value) {}
-};
-class decoder {
-public:
-    decoder(std::vector<generic_instruction_descriptor> instr_list);
-    uint32_t decode_instr(uint32_t word);
-
-private:
-    decoding_tree_node root{decoding_tree_node(std::numeric_limits<uint32_t>::max())};
-    void populate_decoding_tree(decoding_tree_node& root);
-    uint32_t _decode_instr(decoding_tree_node const& node, uint32_t word);
-};
\ No newline at end of file
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index aa930ff..1c1d410 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -44,7 +44,7 @@
 #include <exception>
 #include <vector>
 #include <sstream>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 
 #ifndef FMT_HEADER_ONLY
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index c5cd06f..6f098c0 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -36,7 +36,7 @@
 #include <iss/iss.h>
 #include <iss/llvm/vm_base.h>
 #include <util/logging.h>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 1969679..2aa5ab6 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -37,7 +37,7 @@
 #include <iss/tcc/vm_base.h>
 #include <util/logging.h>
 #include <sstream>
-#include <vm/instruction_decoder.h>
+#include <iss/instruction_decoder.h>
 
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY

From 04b7a09b19e2d5bad424e4b09f1438e17a133a5f Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 25 Jul 2024 17:25:12 +0200
Subject: [PATCH 047/100] updates date in templates

---
 gen_input/templates/CORENAME.cpp.gtl      | 2 +-
 gen_input/templates/CORENAME.h.gtl        | 2 +-
 gen_input/templates/CORENAME_sysc.cpp.gtl | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/gen_input/templates/CORENAME.cpp.gtl b/gen_input/templates/CORENAME.cpp.gtl
index c7a0299..05a4f39 100644
--- a/gen_input/templates/CORENAME.cpp.gtl
+++ b/gen_input/templates/CORENAME.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017 - 2020 MINRES Technologies GmbH
+ * Copyright (C) 2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/gen_input/templates/CORENAME.h.gtl b/gen_input/templates/CORENAME.h.gtl
index f08ce13..2a6a5b8 100644
--- a/gen_input/templates/CORENAME.h.gtl
+++ b/gen_input/templates/CORENAME.h.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017 - 2021 MINRES Technologies GmbH
+ * Copyright (C) 2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/gen_input/templates/CORENAME_sysc.cpp.gtl b/gen_input/templates/CORENAME_sysc.cpp.gtl
index 6163aa1..21cff46 100644
--- a/gen_input/templates/CORENAME_sysc.cpp.gtl
+++ b/gen_input/templates/CORENAME_sysc.cpp.gtl
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2023 MINRES Technologies GmbH
+ * Copyright (C) 2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without

From d2efb23ff74a3b68de1228653c28cb05c4eaebc1 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Thu, 25 Jul 2024 19:33:40 +0200
Subject: [PATCH 048/100] fixes cache behavior for fetches

---
 src/iss/arch/wt_cache.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/iss/arch/wt_cache.h b/src/iss/arch/wt_cache.h
index 967d464..61e64fe 100644
--- a/src/iss/arch/wt_cache.h
+++ b/src/iss/arch/wt_cache.h
@@ -119,7 +119,7 @@ template <typename BASE> iss::status iss::arch::wt_cache<BASE>::read_cache(phys_
         icache_ptr.reset(new cache::cache(size, line_sz, ways));
         dcache_ptr.reset(new cache::cache(size, line_sz, ways));
     }
-    if((a.val & io_addr_mask) != io_address) {
+    if((a.access & iss::access_type::FETCH)== iss::access_type::FETCH || (a.val & io_addr_mask) != io_address) {
         auto set_addr = (a.val & (size - 1)) >> util::ilog2(line_sz * ways);
         auto tag_addr = a.val >> util::ilog2(line_sz);
         auto& set = (is_fetch(a.access) ? icache_ptr : dcache_ptr)->sets[set_addr];

From a365110054b843d4023cd63e87ac5560c55dc21b Mon Sep 17 00:00:00 2001
From: stas <stas@minres.com>
Date: Tue, 30 Jul 2024 13:34:23 +0200
Subject: [PATCH 049/100] fix format

---
 src/iss/arch/wt_cache.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/iss/arch/wt_cache.h b/src/iss/arch/wt_cache.h
index 61e64fe..9b6a9fb 100644
--- a/src/iss/arch/wt_cache.h
+++ b/src/iss/arch/wt_cache.h
@@ -119,7 +119,7 @@ template <typename BASE> iss::status iss::arch::wt_cache<BASE>::read_cache(phys_
         icache_ptr.reset(new cache::cache(size, line_sz, ways));
         dcache_ptr.reset(new cache::cache(size, line_sz, ways));
     }
-    if((a.access & iss::access_type::FETCH)== iss::access_type::FETCH || (a.val & io_addr_mask) != io_address) {
+    if((a.access & iss::access_type::FETCH) == iss::access_type::FETCH || (a.val & io_addr_mask) != io_address) {
         auto set_addr = (a.val & (size - 1)) >> util::ilog2(line_sz * ways);
         auto tag_addr = a.val >> util::ilog2(line_sz);
         auto& set = (is_fetch(a.access) ? icache_ptr : dcache_ptr)->sets[set_addr];

From 39d2518fdda2d8019cc1c25e1ce99cfafff079e3 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Sun, 28 Jul 2024 15:36:12 +0200
Subject: [PATCH 050/100] checkin: tgc5f builds and runs through

---
 gen_input/templates/interp/CORENAME.cpp.gtl |  7 ++++++-
 src/iss/arch/riscv_hart_m_p.h               | 11 +++++++++++
 2 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 6804f57..8fcb64f 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -100,7 +100,12 @@ protected:
     using compile_ret_t = virt_addr_t;
     using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr);
 
-    inline const char *name(size_t index){return index<traits::reg_aliases.size()?traits::reg_aliases[index]:"illegal";}
+    inline const char *name(size_t index){return traits::reg_aliases.at(index);}
+<%
+def fcsr = registers.find {it.name=='FCSR'}
+if(fcsr != null) {%>
+    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}     
+<%}%>
 
     virt_addr_t execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit) override;
 
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 30c15e4..ed59015 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -39,6 +39,7 @@
 #include "iss/instrumentation_if.h"
 #include "iss/log_categories.h"
 #include "iss/vm_if.h"
+#include "iss/vm_types.h"
 #include "riscv_hart_common.h"
 #include <stdexcept>
 #ifndef FMT_HEADER_ONLY
@@ -691,6 +692,11 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
         case traits<BASE>::CSR: {
             if(length != sizeof(reg_t))
                 return iss::Err;
+            // We emulate the FCSR in the architectural state
+            if(addr == 3) {
+                *data = this->get_fcsr();
+                return iss::Ok;
+            }
             return read_csr(addr, *reinterpret_cast<reg_t* const>(data));
         } break;
         case traits<BASE>::FENCE: {
@@ -822,6 +828,11 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
         case traits<BASE>::CSR: {
             if(length != sizeof(reg_t))
                 return iss::Err;
+            // We emulate the FCSR in the architectural state
+            if(addr == 3) {
+                this->set_fcsr(*data);
+                return iss::Ok;
+            }
             return write_csr(addr, *reinterpret_cast<const reg_t*>(data));
         } break;
         case traits<BASE>::FENCE: {

From 17dcba4b90102fa976e38c7749c560f3c18acf4e Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 29 Jul 2024 15:33:50 +0200
Subject: [PATCH 051/100] updates softfloat to #b51ef8f of softfloat3

https://github.com/ucb-bar/berkeley-softfloat-3/
---
 softfloat/.gitignore                          |    2 +
 softfloat/CMakeLists.txt                      |    1 +
 softfloat/COPYING.txt                         |   74 +-
 softfloat/README.html                         |   98 +-
 softfloat/README.md                           |   24 +
 softfloat/README.txt                          |   42 +-
 softfloat/build/Linux-386-GCC/Makefile        |  650 ++--
 softfloat/build/Linux-386-GCC/platform.h      |  105 +-
 softfloat/build/Linux-386-SSE2-GCC/Makefile   |  650 ++--
 softfloat/build/Linux-386-SSE2-GCC/platform.h |  105 +-
 softfloat/build/Linux-ARM-VFPv2-GCC/Makefile  |  646 ++--
 .../build/Linux-ARM-VFPv2-GCC/platform.h      |  105 +-
 softfloat/build/Linux-RISCV64-GCC/Makefile    |  399 +++
 softfloat/build/Linux-RISCV64-GCC/platform.h  |   54 +
 softfloat/build/Linux-x86_64-GCC/Makefile     |  787 ++---
 softfloat/build/Linux-x86_64-GCC/platform.h   |  112 +-
 softfloat/build/Win32-MinGW/Makefile          |  650 ++--
 softfloat/build/Win32-MinGW/platform.h        |  105 +-
 softfloat/build/Win32-SSE2-MinGW/Makefile     |  650 ++--
 softfloat/build/Win32-SSE2-MinGW/platform.h   |  105 +-
 softfloat/build/Win64-MinGW-w64/Makefile      |  780 ++---
 softfloat/build/Win64-MinGW-w64/platform.h    |  107 +-
 softfloat/build/template-FAST_INT64/Makefile  |  787 ++---
 .../build/template-FAST_INT64/platform.h      |   99 +-
 .../build/template-not-FAST_INT64/Makefile    |  650 ++--
 .../build/template-not-FAST_INT64/platform.h  |   99 +-
 softfloat/doc/SoftFloat-history.html          |  516 +--
 softfloat/doc/SoftFloat-source.html           | 1372 ++++----
 softfloat/doc/SoftFloat.html                  | 3054 ++++++++---------
 .../source/8086-SSE/extF80M_isSignalingNaN.c  |  114 +-
 .../source/8086-SSE/f128M_isSignalingNaN.c    |  120 +-
 .../source/8086-SSE/s_bf16UIToCommonNaN.c     |   59 +
 .../source/8086-SSE/s_commonNaNToBF16UI.c     |   51 +
 .../source/8086-SSE/s_commonNaNToExtF80M.c    |  112 +-
 .../source/8086-SSE/s_commonNaNToExtF80UI.c   |  112 +-
 .../source/8086-SSE/s_commonNaNToF128M.c      |  112 +-
 .../source/8086-SSE/s_commonNaNToF128UI.c     |  110 +-
 .../source/8086-SSE/s_commonNaNToF16UI.c      |  102 +-
 .../source/8086-SSE/s_commonNaNToF32UI.c      |  102 +-
 .../source/8086-SSE/s_commonNaNToF64UI.c      |  106 +-
 .../source/8086-SSE/s_extF80MToCommonNaN.c    |  124 +-
 .../source/8086-SSE/s_extF80UIToCommonNaN.c   |  124 +-
 .../source/8086-SSE/s_f128MToCommonNaN.c      |  124 +-
 .../source/8086-SSE/s_f128UIToCommonNaN.c     |  130 +-
 .../source/8086-SSE/s_f16UIToCommonNaN.c      |  118 +-
 .../source/8086-SSE/s_f32UIToCommonNaN.c      |  118 +-
 .../source/8086-SSE/s_f64UIToCommonNaN.c      |  118 +-
 .../source/8086-SSE/s_propagateNaNExtF80M.c   |  214 +-
 .../source/8086-SSE/s_propagateNaNExtF80UI.c  |  212 +-
 .../source/8086-SSE/s_propagateNaNF128M.c     |  152 +-
 .../source/8086-SSE/s_propagateNaNF128UI.c    |  162 +-
 .../source/8086-SSE/s_propagateNaNF16UI.c     |  126 +-
 .../source/8086-SSE/s_propagateNaNF32UI.c     |  126 +-
 .../source/8086-SSE/s_propagateNaNF64UI.c     |  126 +-
 .../source/8086-SSE/softfloat_raiseFlags.c    |  104 +-
 softfloat/source/8086-SSE/specialize.h        |  743 ++--
 .../source/8086/extF80M_isSignalingNaN.c      |  114 +-
 softfloat/source/8086/f128M_isSignalingNaN.c  |  120 +-
 softfloat/source/8086/s_commonNaNToExtF80M.c  |  112 +-
 softfloat/source/8086/s_commonNaNToExtF80UI.c |  112 +-
 softfloat/source/8086/s_commonNaNToF128M.c    |  112 +-
 softfloat/source/8086/s_commonNaNToF128UI.c   |  110 +-
 softfloat/source/8086/s_commonNaNToF16UI.c    |  102 +-
 softfloat/source/8086/s_commonNaNToF32UI.c    |  102 +-
 softfloat/source/8086/s_commonNaNToF64UI.c    |  106 +-
 softfloat/source/8086/s_extF80MToCommonNaN.c  |  124 +-
 softfloat/source/8086/s_extF80UIToCommonNaN.c |  124 +-
 softfloat/source/8086/s_f128MToCommonNaN.c    |  124 +-
 softfloat/source/8086/s_f128UIToCommonNaN.c   |  130 +-
 softfloat/source/8086/s_f16UIToCommonNaN.c    |  118 +-
 softfloat/source/8086/s_f32UIToCommonNaN.c    |  118 +-
 softfloat/source/8086/s_f64UIToCommonNaN.c    |  118 +-
 softfloat/source/8086/s_propagateNaNExtF80M.c |  214 +-
 .../source/8086/s_propagateNaNExtF80UI.c      |  212 +-
 softfloat/source/8086/s_propagateNaNF128M.c   |  216 +-
 softfloat/source/8086/s_propagateNaNF128UI.c  |  210 +-
 softfloat/source/8086/s_propagateNaNF16UI.c   |  168 +-
 softfloat/source/8086/s_propagateNaNF32UI.c   |  168 +-
 softfloat/source/8086/s_propagateNaNF64UI.c   |  168 +-
 softfloat/source/8086/softfloat_raiseFlags.c  |  104 +-
 softfloat/source/8086/specialize.h            |  722 ++--
 .../extF80M_isSignalingNaN.c                  |  114 +-
 .../f128M_isSignalingNaN.c                    |  120 +-
 .../s_commonNaNToExtF80M.c                    |  114 +-
 .../s_commonNaNToExtF80UI.c                   |  114 +-
 .../ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c |  120 +-
 .../s_commonNaNToF128UI.c                     |  112 +-
 .../ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c |   10 +-
 .../ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c |   10 +-
 .../ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c |   10 +-
 .../s_extF80MToCommonNaN.c                    |   10 +-
 .../s_extF80UIToCommonNaN.c                   |   10 +-
 .../ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c |   10 +-
 .../s_f128UIToCommonNaN.c                     |   10 +-
 .../ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c |   10 +-
 .../ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c |   10 +-
 .../ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c |   10 +-
 .../s_propagateNaNExtF80M.c                   |  148 +-
 .../s_propagateNaNExtF80UI.c                  |  146 +-
 .../s_propagateNaNF128M.c                     |  136 +-
 .../s_propagateNaNF128UI.c                    |  146 +-
 .../s_propagateNaNF16UI.c                     |  116 +-
 .../s_propagateNaNF32UI.c                     |  116 +-
 .../s_propagateNaNF64UI.c                     |  116 +-
 .../softfloat_raiseFlags.c                    |  104 +-
 .../source/ARM-VFPv2-defaultNaN/specialize.h  |  800 ++---
 .../source/ARM-VFPv2/extF80M_isSignalingNaN.c |  114 +-
 .../source/ARM-VFPv2/f128M_isSignalingNaN.c   |  120 +-
 .../source/ARM-VFPv2/s_commonNaNToExtF80M.c   |  112 +-
 .../source/ARM-VFPv2/s_commonNaNToExtF80UI.c  |  112 +-
 .../source/ARM-VFPv2/s_commonNaNToF128M.c     |  112 +-
 .../source/ARM-VFPv2/s_commonNaNToF128UI.c    |  110 +-
 .../source/ARM-VFPv2/s_commonNaNToF16UI.c     |  102 +-
 .../source/ARM-VFPv2/s_commonNaNToF32UI.c     |  102 +-
 .../source/ARM-VFPv2/s_commonNaNToF64UI.c     |  106 +-
 .../source/ARM-VFPv2/s_extF80MToCommonNaN.c   |  124 +-
 .../source/ARM-VFPv2/s_extF80UIToCommonNaN.c  |  124 +-
 .../source/ARM-VFPv2/s_f128MToCommonNaN.c     |  124 +-
 .../source/ARM-VFPv2/s_f128UIToCommonNaN.c    |  130 +-
 .../source/ARM-VFPv2/s_f16UIToCommonNaN.c     |  118 +-
 .../source/ARM-VFPv2/s_f32UIToCommonNaN.c     |  118 +-
 .../source/ARM-VFPv2/s_f64UIToCommonNaN.c     |  118 +-
 .../source/ARM-VFPv2/s_propagateNaNExtF80M.c  |  172 +-
 .../source/ARM-VFPv2/s_propagateNaNExtF80UI.c |  166 +-
 .../source/ARM-VFPv2/s_propagateNaNF128M.c    |  154 +-
 .../source/ARM-VFPv2/s_propagateNaNF128UI.c   |  166 +-
 .../source/ARM-VFPv2/s_propagateNaNF16UI.c    |  126 +-
 .../source/ARM-VFPv2/s_propagateNaNF32UI.c    |  126 +-
 .../source/ARM-VFPv2/s_propagateNaNF64UI.c    |  126 +-
 .../source/ARM-VFPv2/softfloat_raiseFlags.c   |  104 +-
 softfloat/source/ARM-VFPv2/specialize.h       |  722 ++--
 .../source/RISCV/extF80M_isSignalingNaN.c     |  114 +-
 softfloat/source/RISCV/f128M_isSignalingNaN.c |  120 +-
 softfloat/source/RISCV/s_bf16UIToCommonNaN.c  |    5 +
 softfloat/source/RISCV/s_commonNaNToBF16UI.c  |    5 +
 softfloat/source/RISCV/s_commonNaNToExtF80M.c |  113 +-
 .../source/RISCV/s_commonNaNToExtF80UI.c      |  113 +-
 softfloat/source/RISCV/s_commonNaNToF128M.c   |  116 +-
 softfloat/source/RISCV/s_commonNaNToF128UI.c  |  111 +-
 softfloat/source/RISCV/s_commonNaNToF16UI.c   |   56 +-
 softfloat/source/RISCV/s_commonNaNToF32UI.c   |   56 +-
 softfloat/source/RISCV/s_commonNaNToF64UI.c   |   58 +-
 softfloat/source/RISCV/s_extF80MToCommonNaN.c |   67 +-
 .../source/RISCV/s_extF80UIToCommonNaN.c      |   67 +-
 softfloat/source/RISCV/s_f128MToCommonNaN.c   |   67 +-
 softfloat/source/RISCV/s_f128UIToCommonNaN.c  |   70 +-
 softfloat/source/RISCV/s_f16UIToCommonNaN.c   |   64 +-
 softfloat/source/RISCV/s_f32UIToCommonNaN.c   |   64 +-
 softfloat/source/RISCV/s_f64UIToCommonNaN.c   |   64 +-
 .../source/RISCV/s_propagateNaNExtF80M.c      |  181 +-
 .../source/RISCV/s_propagateNaNExtF80UI.c     |  179 +-
 softfloat/source/RISCV/s_propagateNaNF128M.c  |  144 +-
 softfloat/source/RISCV/s_propagateNaNF128UI.c |  154 +-
 softfloat/source/RISCV/s_propagateNaNF16UI.c  |  121 +-
 softfloat/source/RISCV/s_propagateNaNF32UI.c  |  121 +-
 softfloat/source/RISCV/s_propagateNaNF64UI.c  |  121 +-
 softfloat/source/RISCV/softfloat_raiseFlags.c |  104 +-
 softfloat/source/RISCV/specialize.h           |  779 +++--
 softfloat/source/bf16_isSignalingNaN.c        |   51 +
 softfloat/source/bf16_to_f32.c                |   90 +
 softfloat/source/extF80M_add.c                |  200 +-
 softfloat/source/extF80M_div.c                |  388 +--
 softfloat/source/extF80M_eq.c                 |  196 +-
 softfloat/source/extF80M_eq_signaling.c       |  184 +-
 softfloat/source/extF80M_le.c                 |  212 +-
 softfloat/source/extF80M_le_quiet.c           |  224 +-
 softfloat/source/extF80M_lt.c                 |  212 +-
 softfloat/source/extF80M_lt_quiet.c           |  224 +-
 softfloat/source/extF80M_mul.c                |  278 +-
 softfloat/source/extF80M_rem.c                |  408 +--
 softfloat/source/extF80M_roundToInt.c         |  352 +-
 softfloat/source/extF80M_sqrt.c               |  360 +-
 softfloat/source/extF80M_sub.c                |  200 +-
 softfloat/source/extF80M_to_f128M.c           |  250 +-
 softfloat/source/extF80M_to_f16.c             |  224 +-
 softfloat/source/extF80M_to_f32.c             |  224 +-
 softfloat/source/extF80M_to_f64.c             |  224 +-
 softfloat/source/extF80M_to_i32.c             |  200 +-
 softfloat/source/extF80M_to_i32_r_minMag.c    |  240 +-
 softfloat/source/extF80M_to_i64.c             |  194 +-
 softfloat/source/extF80M_to_i64_r_minMag.c    |  230 +-
 softfloat/source/extF80M_to_ui32.c            |  202 +-
 softfloat/source/extF80M_to_ui32_r_minMag.c   |  222 +-
 softfloat/source/extF80M_to_ui64.c            |  194 +-
 softfloat/source/extF80M_to_ui64_r_minMag.c   |  216 +-
 softfloat/source/extF80_add.c                 |  160 +-
 softfloat/source/extF80_div.c                 |  406 +--
 softfloat/source/extF80_eq.c                  |  146 +-
 softfloat/source/extF80_eq_signaling.c        |  134 +-
 softfloat/source/extF80_isSignalingNaN.c      |  102 +-
 softfloat/source/extF80_le.c                  |  146 +-
 softfloat/source/extF80_le_quiet.c            |  156 +-
 softfloat/source/extF80_lt.c                  |  146 +-
 softfloat/source/extF80_lt_quiet.c            |  156 +-
 softfloat/source/extF80_mul.c                 |  316 +-
 softfloat/source/extF80_rem.c                 |  450 +--
 softfloat/source/extF80_roundToInt.c          |  308 +-
 softfloat/source/extF80_sqrt.c                |  352 +-
 softfloat/source/extF80_sub.c                 |  160 +-
 softfloat/source/extF80_to_f128.c             |  150 +-
 softfloat/source/extF80_to_f16.c              |  192 +-
 softfloat/source/extF80_to_f32.c              |  192 +-
 softfloat/source/extF80_to_f64.c              |  192 +-
 softfloat/source/extF80_to_i32.c              |  166 +-
 softfloat/source/extF80_to_i32_r_minMag.c     |  194 +-
 softfloat/source/extF80_to_i64.c              |  178 +-
 softfloat/source/extF80_to_i64_r_minMag.c     |  188 +-
 softfloat/source/extF80_to_ui32.c             |  166 +-
 softfloat/source/extF80_to_ui32_r_minMag.c    |  176 +-
 softfloat/source/extF80_to_ui64.c             |  168 +-
 softfloat/source/extF80_to_ui64_r_minMag.c    |  176 +-
 softfloat/source/f128M_add.c                  |  194 +-
 softfloat/source/f128M_div.c                  |  374 +-
 softfloat/source/f128M_eq.c                   |  200 +-
 softfloat/source/f128M_eq_signaling.c         |  184 +-
 softfloat/source/f128M_le.c                   |  186 +-
 softfloat/source/f128M_le_quiet.c             |  192 +-
 softfloat/source/f128M_lt.c                   |  186 +-
 softfloat/source/f128M_lt_quiet.c             |  192 +-
 softfloat/source/f128M_mul.c                  |  316 +-
 softfloat/source/f128M_mulAdd.c               |  184 +-
 softfloat/source/f128M_rem.c                  |  364 +-
 softfloat/source/f128M_roundToInt.c           |  446 +--
 softfloat/source/f128M_sqrt.c                 |  456 +--
 softfloat/source/f128M_sub.c                  |  194 +-
 softfloat/source/f128M_to_extF80M.c           |  202 +-
 softfloat/source/f128M_to_f16.c               |  226 +-
 softfloat/source/f128M_to_f32.c               |  218 +-
 softfloat/source/f128M_to_f64.c               |  224 +-
 softfloat/source/f128M_to_i32.c               |  196 +-
 softfloat/source/f128M_to_i32_r_minMag.c      |  212 +-
 softfloat/source/f128M_to_i64.c               |  204 +-
 softfloat/source/f128M_to_i64_r_minMag.c      |  248 +-
 softfloat/source/f128M_to_ui32.c              |  196 +-
 softfloat/source/f128M_to_ui32_r_minMag.c     |  204 +-
 softfloat/source/f128M_to_ui64.c              |  204 +-
 softfloat/source/f128M_to_ui64_r_minMag.c     |  228 +-
 softfloat/source/f128_add.c                   |  156 +-
 softfloat/source/f128_div.c                   |  398 +--
 softfloat/source/f128_eq.c                    |  146 +-
 softfloat/source/f128_eq_signaling.c          |  134 +-
 softfloat/source/f128_isSignalingNaN.c        |  102 +-
 softfloat/source/f128_le.c                    |  144 +-
 softfloat/source/f128_le_quiet.c              |  156 +-
 softfloat/source/f128_lt.c                    |  144 +-
 softfloat/source/f128_lt_quiet.c              |  156 +-
 softfloat/source/f128_mul.c                   |  326 +-
 softfloat/source/f128_mulAdd.c                |  126 +-
 softfloat/source/f128_rem.c                   |  380 +-
 softfloat/source/f128_roundToInt.c            |  344 +-
 softfloat/source/f128_sqrt.c                  |  402 +--
 softfloat/source/f128_sub.c                   |  156 +-
 softfloat/source/f128_to_extF80.c             |  218 +-
 softfloat/source/f128_to_f16.c                |  190 +-
 softfloat/source/f128_to_f32.c                |  190 +-
 softfloat/source/f128_to_f64.c                |  200 +-
 softfloat/source/f128_to_i32.c                |  170 +-
 softfloat/source/f128_to_i32_r_minMag.c       |  200 +-
 softfloat/source/f128_to_i64.c                |  190 +-
 softfloat/source/f128_to_i64_r_minMag.c       |  226 +-
 softfloat/source/f128_to_ui32.c               |  172 +-
 softfloat/source/f128_to_ui32_r_minMag.c      |  178 +-
 softfloat/source/f128_to_ui64.c               |  192 +-
 softfloat/source/f128_to_ui64_r_minMag.c      |  210 +-
 softfloat/source/f16_add.c                    |  140 +-
 softfloat/source/f16_div.c                    |  372 +-
 softfloat/source/f16_eq.c                     |  132 +-
 softfloat/source/f16_eq_signaling.c           |  122 +-
 softfloat/source/f16_isSignalingNaN.c         |  102 +-
 softfloat/source/f16_le.c                     |  132 +-
 softfloat/source/f16_le_quiet.c               |  142 +-
 softfloat/source/f16_lt.c                     |  132 +-
 softfloat/source/f16_lt_quiet.c               |  142 +-
 softfloat/source/f16_mul.c                    |  280 +-
 softfloat/source/f16_mulAdd.c                 |  120 +-
 softfloat/source/f16_rem.c                    |  342 +-
 softfloat/source/f16_roundToInt.c             |  240 +-
 softfloat/source/f16_sqrt.c                   |  272 +-
 softfloat/source/f16_sub.c                    |  140 +-
 softfloat/source/f16_to_extF80.c              |  202 +-
 softfloat/source/f16_to_extF80M.c             |  222 +-
 softfloat/source/f16_to_f128.c                |  192 +-
 softfloat/source/f16_to_f128M.c               |  222 +-
 softfloat/source/f16_to_f32.c                 |  186 +-
 softfloat/source/f16_to_f64.c                 |  186 +-
 softfloat/source/f16_to_i32.c                 |  174 +-
 softfloat/source/f16_to_i32_r_minMag.c        |  176 +-
 softfloat/source/f16_to_i64.c                 |  174 +-
 softfloat/source/f16_to_i64_r_minMag.c        |  176 +-
 softfloat/source/f16_to_ui32.c                |  168 +-
 softfloat/source/f16_to_ui32_r_minMag.c       |  174 +-
 softfloat/source/f16_to_ui64.c                |  192 +-
 softfloat/source/f16_to_ui64_r_minMag.c       |  174 +-
 softfloat/source/f32_add.c                    |  140 +-
 softfloat/source/f32_div.c                    |  360 +-
 softfloat/source/f32_eq.c                     |  132 +-
 softfloat/source/f32_eq_signaling.c           |  122 +-
 softfloat/source/f32_isSignalingNaN.c         |  102 +-
 softfloat/source/f32_le.c                     |  132 +-
 softfloat/source/f32_le_quiet.c               |  142 +-
 softfloat/source/f32_lt.c                     |  132 +-
 softfloat/source/f32_lt_quiet.c               |  142 +-
 softfloat/source/f32_mul.c                    |  274 +-
 softfloat/source/f32_mulAdd.c                 |  120 +-
 softfloat/source/f32_rem.c                    |  336 +-
 softfloat/source/f32_roundToInt.c             |  240 +-
 softfloat/source/f32_sqrt.c                   |  242 +-
 softfloat/source/f32_sub.c                    |  140 +-
 softfloat/source/f32_to_bf16.c                |  105 +
 softfloat/source/f32_to_extF80.c              |  202 +-
 softfloat/source/f32_to_extF80M.c             |  222 +-
 softfloat/source/f32_to_f128.c                |  192 +-
 softfloat/source/f32_to_f128M.c               |  230 +-
 softfloat/source/f32_to_f16.c                 |  179 +-
 softfloat/source/f32_to_f64.c                 |  186 +-
 softfloat/source/f32_to_i32.c                 |  168 +-
 softfloat/source/f32_to_i32_r_minMag.c        |  178 +-
 softfloat/source/f32_to_i64.c                 |  192 +-
 softfloat/source/f32_to_i64_r_minMag.c        |  188 +-
 softfloat/source/f32_to_ui32.c                |  168 +-
 softfloat/source/f32_to_ui32_r_minMag.c       |  176 +-
 softfloat/source/f32_to_ui64.c                |  192 +-
 softfloat/source/f32_to_ui64_r_minMag.c       |  180 +-
 softfloat/source/f64_add.c                    |  148 +-
 softfloat/source/f64_div.c                    |  344 +-
 softfloat/source/f64_eq.c                     |  132 +-
 softfloat/source/f64_eq_signaling.c           |  122 +-
 softfloat/source/f64_isSignalingNaN.c         |  102 +-
 softfloat/source/f64_le.c                     |  134 +-
 softfloat/source/f64_le_quiet.c               |  144 +-
 softfloat/source/f64_lt.c                     |  134 +-
 softfloat/source/f64_lt_quiet.c               |  144 +-
 softfloat/source/f64_mul.c                    |  300 +-
 softfloat/source/f64_mulAdd.c                 |  120 +-
 softfloat/source/f64_rem.c                    |  378 +-
 softfloat/source/f64_roundToInt.c             |  240 +-
 softfloat/source/f64_sqrt.c                   |  266 +-
 softfloat/source/f64_sub.c                    |  148 +-
 softfloat/source/f64_to_extF80.c              |  202 +-
 softfloat/source/f64_to_extF80M.c             |  222 +-
 softfloat/source/f64_to_f128.c                |  196 +-
 softfloat/source/f64_to_f128M.c               |  234 +-
 softfloat/source/f64_to_f16.c                 |  176 +-
 softfloat/source/f64_to_f32.c                 |  176 +-
 softfloat/source/f64_to_i32.c                 |  164 +-
 softfloat/source/f64_to_i32_r_minMag.c        |  192 +-
 softfloat/source/f64_to_i64.c                 |  206 +-
 softfloat/source/f64_to_i64_r_minMag.c        |  200 +-
 softfloat/source/f64_to_ui32.c                |  164 +-
 softfloat/source/f64_to_ui32_r_minMag.c       |  176 +-
 softfloat/source/f64_to_ui64.c                |  206 +-
 softfloat/source/f64_to_ui64_r_minMag.c       |  186 +-
 softfloat/source/i32_to_extF80.c              |  130 +-
 softfloat/source/i32_to_extF80M.c             |  156 +-
 softfloat/source/i32_to_f128.c                |  128 +-
 softfloat/source/i32_to_f128M.c               |  162 +-
 softfloat/source/i32_to_f16.c                 |  142 +-
 softfloat/source/i32_to_f32.c                 |  116 +-
 softfloat/source/i32_to_f64.c                 |  130 +-
 softfloat/source/i64_to_extF80.c              |  130 +-
 softfloat/source/i64_to_extF80M.c             |  156 +-
 softfloat/source/i64_to_f128.c                |  144 +-
 softfloat/source/i64_to_f128M.c               |  184 +-
 softfloat/source/i64_to_f16.c                 |  140 +-
 softfloat/source/i64_to_f32.c                 |  140 +-
 softfloat/source/i64_to_f64.c                 |  116 +-
 softfloat/source/include/internals.h          |  532 +--
 softfloat/source/include/opts-GCC.h           |  226 +-
 softfloat/source/include/primitiveTypes.h     |  185 +-
 softfloat/source/include/primitives.h         | 2190 ++++++------
 softfloat/source/include/softfloat.h          |  740 ++--
 softfloat/source/include/softfloat_types.h    |  176 +-
 softfloat/source/s_add128.c                   |  110 +-
 softfloat/source/s_add256M.c                  |  130 +-
 softfloat/source/s_addCarryM.c                |  140 +-
 softfloat/source/s_addComplCarryM.c           |  140 +-
 softfloat/source/s_addExtF80M.c               |  372 +-
 softfloat/source/s_addF128M.c                 |  422 +--
 softfloat/source/s_addM.c                     |  140 +-
 softfloat/source/s_addMagsExtF80.c            |  312 +-
 softfloat/source/s_addMagsF128.c              |  308 +-
 softfloat/source/s_addMagsF16.c               |  366 +-
 softfloat/source/s_addMagsF32.c               |  252 +-
 softfloat/source/s_addMagsF64.c               |  256 +-
 softfloat/source/s_approxRecip32_1.c          |  132 +-
 softfloat/source/s_approxRecipSqrt32_1.c      |  146 +-
 softfloat/source/s_approxRecipSqrt_1Ks.c      |   98 +-
 softfloat/source/s_approxRecip_1Ks.c          |   98 +-
 softfloat/source/s_compare128M.c              |  124 +-
 softfloat/source/s_compare96M.c               |  124 +-
 softfloat/source/s_compareNonnormExtF80M.c    |  222 +-
 softfloat/source/s_countLeadingZeros16.c      |  120 +-
 softfloat/source/s_countLeadingZeros32.c      |  128 +-
 softfloat/source/s_countLeadingZeros64.c      |  146 +-
 softfloat/source/s_countLeadingZeros8.c       |  118 +-
 softfloat/source/s_eq128.c                    |  102 +-
 softfloat/source/s_invalidExtF80M.c           |   98 +-
 softfloat/source/s_invalidF128M.c             |  106 +-
 softfloat/source/s_isNaNF128M.c               |  114 +-
 softfloat/source/s_le128.c                    |  102 +-
 softfloat/source/s_lt128.c                    |  102 +-
 softfloat/source/s_mul128By32.c               |  116 +-
 softfloat/source/s_mul128MTo256M.c            |  200 +-
 softfloat/source/s_mul128To256M.c             |  142 +-
 softfloat/source/s_mul64ByShifted32To128.c    |  112 +-
 softfloat/source/s_mul64To128.c               |  132 +-
 softfloat/source/s_mul64To128M.c              |  136 +-
 softfloat/source/s_mulAddF128.c               |  700 ++--
 softfloat/source/s_mulAddF128M.c              |  764 ++---
 softfloat/source/s_mulAddF16.c                |  452 +--
 softfloat/source/s_mulAddF32.c                |  448 +--
 softfloat/source/s_mulAddF64.c                |  992 +++---
 softfloat/source/s_negXM.c                    |  126 +-
 softfloat/source/s_normExtF80SigM.c           |  104 +-
 softfloat/source/s_normRoundPackMToExtF80M.c  |  156 +-
 softfloat/source/s_normRoundPackMToF128M.c    |  146 +-
 softfloat/source/s_normRoundPackToExtF80.c    |  142 +-
 softfloat/source/s_normRoundPackToF128.c      |  162 +-
 softfloat/source/s_normRoundPackToF16.c       |  116 +-
 softfloat/source/s_normRoundPackToF32.c       |  116 +-
 softfloat/source/s_normRoundPackToF64.c       |  116 +-
 softfloat/source/s_normSubnormalBF16Sig.c     |   52 +
 softfloat/source/s_normSubnormalExtF80Sig.c   |  104 +-
 softfloat/source/s_normSubnormalF128Sig.c     |  130 +-
 softfloat/source/s_normSubnormalF128SigM.c    |  122 +-
 softfloat/source/s_normSubnormalF16Sig.c      |  104 +-
 softfloat/source/s_normSubnormalF32Sig.c      |  104 +-
 softfloat/source/s_normSubnormalF64Sig.c      |  104 +-
 softfloat/source/s_remStepMBy32.c             |  172 +-
 softfloat/source/s_roundMToI64.c              |  204 +-
 softfloat/source/s_roundMToUI64.c             |  196 +-
 softfloat/source/s_roundPackMToExtF80M.c      |  512 +--
 softfloat/source/s_roundPackMToF128M.c        |  356 +-
 softfloat/source/s_roundPackToBF16.c          |  114 +
 softfloat/source/s_roundPackToExtF80.c        |  512 +--
 softfloat/source/s_roundPackToF128.c          |  342 +-
 softfloat/source/s_roundPackToF16.c           |  226 +-
 softfloat/source/s_roundPackToF32.c           |  226 +-
 softfloat/source/s_roundPackToF64.c           |  234 +-
 softfloat/source/s_roundToI32.c               |  196 +-
 softfloat/source/s_roundToI64.c               |  202 +-
 softfloat/source/s_roundToUI32.c              |  186 +-
 softfloat/source/s_roundToUI64.c              |  194 +-
 softfloat/source/s_shiftLeftM.c               |  182 +-
 softfloat/source/s_shiftNormSigF128M.c        |  156 +-
 softfloat/source/s_shiftRightJam128.c         |  138 +-
 softfloat/source/s_shiftRightJam128Extra.c    |  154 +-
 softfloat/source/s_shiftRightJam256M.c        |  252 +-
 softfloat/source/s_shiftRightJam32.c          |  102 +-
 softfloat/source/s_shiftRightJam64.c          |  102 +-
 softfloat/source/s_shiftRightJam64Extra.c     |  124 +-
 softfloat/source/s_shiftRightJamM.c           |  202 +-
 softfloat/source/s_shiftRightM.c              |  182 +-
 softfloat/source/s_shortShiftLeft128.c        |  110 +-
 softfloat/source/s_shortShiftLeft64To96M.c    |  112 +-
 softfloat/source/s_shortShiftLeftM.c          |  140 +-
 softfloat/source/s_shortShiftRight128.c       |  110 +-
 softfloat/source/s_shortShiftRightExtendM.c   |  146 +-
 softfloat/source/s_shortShiftRightJam128.c    |  120 +-
 .../source/s_shortShiftRightJam128Extra.c     |  118 +-
 softfloat/source/s_shortShiftRightJam64.c     |  100 +-
 .../source/s_shortShiftRightJam64Extra.c      |  112 +-
 softfloat/source/s_shortShiftRightJamM.c      |  144 +-
 softfloat/source/s_shortShiftRightM.c         |  140 +-
 softfloat/source/s_sub128.c                   |  110 +-
 softfloat/source/s_sub1XM.c                   |  120 +-
 softfloat/source/s_sub256M.c                  |  130 +-
 softfloat/source/s_subM.c                     |  140 +-
 softfloat/source/s_subMagsExtF80.c            |  316 +-
 softfloat/source/s_subMagsF128.c              |  278 +-
 softfloat/source/s_subMagsF16.c               |  374 +-
 softfloat/source/s_subMagsF32.c               |  286 +-
 softfloat/source/s_subMagsF64.c               |  282 +-
 softfloat/source/s_tryPropagateNaNExtF80M.c   |  128 +-
 softfloat/source/s_tryPropagateNaNF128M.c     |  110 +-
 softfloat/source/softfloat_state.c            |  104 +-
 softfloat/source/ui32_to_extF80.c             |  118 +-
 softfloat/source/ui32_to_extF80M.c            |  148 +-
 softfloat/source/ui32_to_f128.c               |  120 +-
 softfloat/source/ui32_to_f128M.c              |  152 +-
 softfloat/source/ui32_to_f16.c                |  130 +-
 softfloat/source/ui32_to_f32.c                |  114 +-
 softfloat/source/ui32_to_f64.c                |  118 +-
 softfloat/source/ui64_to_extF80.c             |  118 +-
 softfloat/source/ui64_to_extF80M.c            |  148 +-
 softfloat/source/ui64_to_f128.c               |  136 +-
 softfloat/source/ui64_to_f128M.c              |  172 +-
 softfloat/source/ui64_to_f16.c                |  128 +-
 softfloat/source/ui64_to_f32.c                |  128 +-
 softfloat/source/ui64_to_f64.c                |  118 +-
 490 files changed, 49569 insertions(+), 48774 deletions(-)
 create mode 100644 softfloat/.gitignore
 create mode 100644 softfloat/README.md
 create mode 100644 softfloat/build/Linux-RISCV64-GCC/Makefile
 create mode 100644 softfloat/build/Linux-RISCV64-GCC/platform.h
 create mode 100644 softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
 create mode 100644 softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
 create mode 100644 softfloat/source/RISCV/s_bf16UIToCommonNaN.c
 create mode 100644 softfloat/source/RISCV/s_commonNaNToBF16UI.c
 create mode 100644 softfloat/source/bf16_isSignalingNaN.c
 create mode 100644 softfloat/source/bf16_to_f32.c
 create mode 100644 softfloat/source/f32_to_bf16.c
 create mode 100644 softfloat/source/s_normSubnormalBF16Sig.c
 create mode 100644 softfloat/source/s_roundPackToBF16.c

diff --git a/softfloat/.gitignore b/softfloat/.gitignore
new file mode 100644
index 0000000..bfdb592
--- /dev/null
+++ b/softfloat/.gitignore
@@ -0,0 +1,2 @@
+build/*/*.o
+build/*/*.a
diff --git a/softfloat/CMakeLists.txt b/softfloat/CMakeLists.txt
index b5766c6..fa2cc62 100644
--- a/softfloat/CMakeLists.txt
+++ b/softfloat/CMakeLists.txt
@@ -335,6 +335,7 @@ target_compile_definitions(softfloat PRIVATE
 	SOFTFLOAT_FAST_DIV32TO16
   	SOFTFLOAT_FAST_DIV64TO32
   	SOFTFLOAT_FAST_INT64
+	__GNUC_STDC_INLINE__=1
 #  	THREAD_LOCAL=__thread
 )
 target_include_directories(softfloat PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/build/Linux-x86_64-GCC)
diff --git a/softfloat/COPYING.txt b/softfloat/COPYING.txt
index 9c05d49..b5690fa 100644
--- a/softfloat/COPYING.txt
+++ b/softfloat/COPYING.txt
@@ -1,37 +1,37 @@
-
-License for Berkeley SoftFloat Release 3e
-
-John R. Hauser
-2018 January 20
-
-The following applies to the whole of SoftFloat Release 3e as well as to
-each source file individually.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions, and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors
-    may be used to endorse or promote products derived from this software
-    without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
+
+License for Berkeley SoftFloat Release 3e
+
+John R. Hauser
+2018 January 20
+
+The following applies to the whole of SoftFloat Release 3e as well as to
+each source file individually.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions, and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
diff --git a/softfloat/README.html b/softfloat/README.html
index 7989e0c..e695c2b 100644
--- a/softfloat/README.html
+++ b/softfloat/README.html
@@ -1,49 +1,49 @@
-
-<HTML>
-
-<HEAD>
-<TITLE>Berkeley SoftFloat Package Overview</TITLE>
-</HEAD>
-
-<BODY>
-
-<H1>Package Overview for Berkeley SoftFloat Release 3e</H1>
-
-<P>
-John R. Hauser<BR>
-2018 January 20<BR>
-</P>
-
-<P>
-Berkeley SoftFloat is a software implementation of binary floating-point that
-conforms to the IEEE Standard for Floating-Point Arithmetic.
-SoftFloat is distributed in the form of C source code.
-Building the SoftFloat sources generates a library file (typically
-<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) containing the
-floating-point subroutines.
-</P>
-
-<P>
-The SoftFloat package is documented in the following files in the
-<CODE>doc</CODE> subdirectory:
-<BLOCKQUOTE>
-<TABLE>
-<TR>
-<TD><A HREF="doc/SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A></TD>
-<TD>Documentation for using the SoftFloat functions.</TD>
-</TR>
-<TR>
-<TD><A HREF="doc/SoftFloat-source.html"><NOBR><CODE>SoftFloat-source.html</CODE></NOBR></A></TD>
-<TD>Documentation for building SoftFloat.</TD>
-</TR>
-<TR>
-<TD><A HREF="doc/SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></A><CODE>&nbsp;&nbsp;&nbsp;</CODE></NOBR></TD>
-<TD>History of the major changes to SoftFloat.</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-Other files in the package comprise the source code for SoftFloat.
-</P>
-
-</BODY>
-
+
+<HTML>
+
+<HEAD>
+<TITLE>Berkeley SoftFloat Package Overview</TITLE>
+</HEAD>
+
+<BODY>
+
+<H1>Package Overview for Berkeley SoftFloat Release 3e</H1>
+
+<P>
+John R. Hauser<BR>
+2018 January 20<BR>
+</P>
+
+<P>
+Berkeley SoftFloat is a software implementation of binary floating-point that
+conforms to the IEEE Standard for Floating-Point Arithmetic.
+SoftFloat is distributed in the form of C source code.
+Building the SoftFloat sources generates a library file (typically
+<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) containing the
+floating-point subroutines.
+</P>
+
+<P>
+The SoftFloat package is documented in the following files in the
+<CODE>doc</CODE> subdirectory:
+<BLOCKQUOTE>
+<TABLE>
+<TR>
+<TD><A HREF="doc/SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A></TD>
+<TD>Documentation for using the SoftFloat functions.</TD>
+</TR>
+<TR>
+<TD><A HREF="doc/SoftFloat-source.html"><NOBR><CODE>SoftFloat-source.html</CODE></NOBR></A></TD>
+<TD>Documentation for building SoftFloat.</TD>
+</TR>
+<TR>
+<TD><A HREF="doc/SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></A><CODE>&nbsp;&nbsp;&nbsp;</CODE></NOBR></TD>
+<TD>History of the major changes to SoftFloat.</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+Other files in the package comprise the source code for SoftFloat.
+</P>
+
+</BODY>
+
diff --git a/softfloat/README.md b/softfloat/README.md
new file mode 100644
index 0000000..d468020
--- /dev/null
+++ b/softfloat/README.md
@@ -0,0 +1,24 @@
+
+Package Overview for Berkeley SoftFloat Release 3e
+==================================================
+
+John R. Hauser<br>
+2018 January 20
+
+
+Berkeley SoftFloat is a software implementation of binary floating-point
+that conforms to the IEEE Standard for Floating-Point Arithmetic.  SoftFloat
+is distributed in the form of C source code.  Building the SoftFloat sources
+generates a library file (typically `softfloat.a` or `libsoftfloat.a`)
+containing the floating-point subroutines.
+
+
+The SoftFloat package is documented in the following files in the `doc`
+subdirectory:
+
+* [SoftFloat.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat.html) Documentation for using the SoftFloat functions.
+* [SoftFloat-source.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-source.html) Documentation for building SoftFloat.
+* [SoftFloat-history.html](http://www.jhauser.us/arithmetic/SoftFloat-3/doc/SoftFloat-history.html) History of the major changes to SoftFloat.
+
+Other files in the package comprise the source code for SoftFloat.
+
diff --git a/softfloat/README.txt b/softfloat/README.txt
index f819baa..1613c76 100644
--- a/softfloat/README.txt
+++ b/softfloat/README.txt
@@ -1,21 +1,21 @@
-
-Package Overview for Berkeley SoftFloat Release 3e
-
-John R. Hauser
-2018 January 20
-
-Berkeley SoftFloat is a software implementation of binary floating-point
-that conforms to the IEEE Standard for Floating-Point Arithmetic.  SoftFloat
-is distributed in the form of C source code.  Building the SoftFloat sources
-generates a library file (typically "softfloat.a" or "libsoftfloat.a")
-containing the floating-point subroutines.
-
-The SoftFloat package is documented in the following files in the "doc"
-subdirectory:
-
-    SoftFloat.html          Documentation for using the SoftFloat functions.
-    SoftFloat-source.html   Documentation for building SoftFloat.
-    SoftFloat-history.html  History of the major changes to SoftFloat.
-
-Other files in the package comprise the source code for SoftFloat.
-
+
+Package Overview for Berkeley SoftFloat Release 3e
+
+John R. Hauser
+2018 January 20
+
+Berkeley SoftFloat is a software implementation of binary floating-point
+that conforms to the IEEE Standard for Floating-Point Arithmetic.  SoftFloat
+is distributed in the form of C source code.  Building the SoftFloat sources
+generates a library file (typically "softfloat.a" or "libsoftfloat.a")
+containing the floating-point subroutines.
+
+The SoftFloat package is documented in the following files in the "doc"
+subdirectory:
+
+    SoftFloat.html          Documentation for using the SoftFloat functions.
+    SoftFloat-source.html   Documentation for building SoftFloat.
+    SoftFloat-history.html  History of the major changes to SoftFloat.
+
+Other files in the package comprise the source code for SoftFloat.
+
diff --git a/softfloat/build/Linux-386-GCC/Makefile b/softfloat/build/Linux-386-GCC/Makefile
index 4181600..faeb397 100644
--- a/softfloat/build/Linux-386-GCC/Makefile
+++ b/softfloat/build/Linux-386-GCC/Makefile
@@ -1,325 +1,325 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
-    $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+    $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Linux-386-GCC/platform.h b/softfloat/build/Linux-386-GCC/platform.h
index eb224b1..d514dbc 100644
--- a/softfloat/build/Linux-386-GCC/platform.h
+++ b/softfloat/build/Linux-386-GCC/platform.h
@@ -1,52 +1,53 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Linux-386-SSE2-GCC/Makefile b/softfloat/build/Linux-386-SSE2-GCC/Makefile
index 1cf6f5e..ced977b 100644
--- a/softfloat/build/Linux-386-SSE2-GCC/Makefile
+++ b/softfloat/build/Linux-386-SSE2-GCC/Makefile
@@ -1,325 +1,325 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086-SSE
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
-    $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+    $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Linux-386-SSE2-GCC/platform.h b/softfloat/build/Linux-386-SSE2-GCC/platform.h
index eb224b1..d514dbc 100644
--- a/softfloat/build/Linux-386-SSE2-GCC/platform.h
+++ b/softfloat/build/Linux-386-SSE2-GCC/platform.h
@@ -1,52 +1,53 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile b/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
index 2565fe5..a1e7c83 100644
--- a/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
+++ b/softfloat/build/Linux-ARM-VFPv2-GCC/Makefile
@@ -1,323 +1,323 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= ARM-VFPv2
-
-SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
-    $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= ARM-VFPv2
+
+SOFTFLOAT_OPTS ?= -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+    $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h b/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
index eb224b1..d514dbc 100644
--- a/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
+++ b/softfloat/build/Linux-ARM-VFPv2-GCC/platform.h
@@ -1,52 +1,53 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Linux-RISCV64-GCC/Makefile b/softfloat/build/Linux-RISCV64-GCC/Makefile
new file mode 100644
index 0000000..b9408c6
--- /dev/null
+++ b/softfloat/build/Linux-RISCV64-GCC/Makefile
@@ -0,0 +1,399 @@
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= RISCV
+MARCH ?= rv64gcv_zfh_zfhmin
+MABI ?= lp64d
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  riscv64-unknown-linux-gnu-gcc -c -march=$(MARCH) -mabi=$(MABI) -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
+    $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_eq128$(OBJ) \
+  s_le128$(OBJ) \
+  s_lt128$(OBJ) \
+  s_shortShiftLeft128$(OBJ) \
+  s_shortShiftRight128$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJam64Extra$(OBJ) \
+  s_shortShiftRightJam128$(OBJ) \
+  s_shortShiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJam64Extra$(OBJ) \
+  s_shiftRightJam128$(OBJ) \
+  s_shiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam256M$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_add128$(OBJ) \
+  s_add256M$(OBJ) \
+  s_sub128$(OBJ) \
+  s_sub256M$(OBJ) \
+  s_mul64ByShifted32To128$(OBJ) \
+  s_mul64To128$(OBJ) \
+  s_mul128By32$(OBJ) \
+  s_mul128To256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_bf16UIToCommonNaN$(OBJ) \
+  s_commonNaNToBF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80UIToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80UI$(OBJ) \
+  s_propagateNaNExtF80UI$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128UIToCommonNaN$(OBJ) \
+  s_commonNaNToF128UI$(OBJ) \
+  s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundToI64$(OBJ) \
+  s_normSubnormalBF16Sig$(OBJ) \
+  s_roundPackToBF16$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_normSubnormalExtF80Sig$(OBJ) \
+  s_roundPackToExtF80$(OBJ) \
+  s_normRoundPackToExtF80$(OBJ) \
+  s_addMagsExtF80$(OBJ) \
+  s_subMagsExtF80$(OBJ) \
+  s_normSubnormalF128Sig$(OBJ) \
+  s_roundPackToF128$(OBJ) \
+  s_normRoundPackToF128$(OBJ) \
+  s_addMagsF128$(OBJ) \
+  s_subMagsF128$(OBJ) \
+  s_mulAddF128$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  bf16_isSignalingNaN$(OBJ) \
+  bf16_to_f32$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_bf16$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80_to_ui32$(OBJ) \
+  extF80_to_ui64$(OBJ) \
+  extF80_to_i32$(OBJ) \
+  extF80_to_i64$(OBJ) \
+  extF80_to_ui32_r_minMag$(OBJ) \
+  extF80_to_ui64_r_minMag$(OBJ) \
+  extF80_to_i32_r_minMag$(OBJ) \
+  extF80_to_i64_r_minMag$(OBJ) \
+  extF80_to_f16$(OBJ) \
+  extF80_to_f32$(OBJ) \
+  extF80_to_f64$(OBJ) \
+  extF80_to_f128$(OBJ) \
+  extF80_roundToInt$(OBJ) \
+  extF80_add$(OBJ) \
+  extF80_sub$(OBJ) \
+  extF80_mul$(OBJ) \
+  extF80_div$(OBJ) \
+  extF80_rem$(OBJ) \
+  extF80_sqrt$(OBJ) \
+  extF80_eq$(OBJ) \
+  extF80_le$(OBJ) \
+  extF80_lt$(OBJ) \
+  extF80_eq_signaling$(OBJ) \
+  extF80_le_quiet$(OBJ) \
+  extF80_lt_quiet$(OBJ) \
+  extF80_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128_to_ui32$(OBJ) \
+  f128_to_ui64$(OBJ) \
+  f128_to_i32$(OBJ) \
+  f128_to_i64$(OBJ) \
+  f128_to_ui32_r_minMag$(OBJ) \
+  f128_to_ui64_r_minMag$(OBJ) \
+  f128_to_i32_r_minMag$(OBJ) \
+  f128_to_i64_r_minMag$(OBJ) \
+  f128_to_f16$(OBJ) \
+  f128_to_f32$(OBJ) \
+  f128_to_extF80$(OBJ) \
+  f128_to_f64$(OBJ) \
+  f128_roundToInt$(OBJ) \
+  f128_add$(OBJ) \
+  f128_sub$(OBJ) \
+  f128_mul$(OBJ) \
+  f128_mulAdd$(OBJ) \
+  f128_div$(OBJ) \
+  f128_rem$(OBJ) \
+  f128_sqrt$(OBJ) \
+  f128_eq$(OBJ) \
+  f128_le$(OBJ) \
+  f128_lt$(OBJ) \
+  f128_eq_signaling$(OBJ) \
+  f128_le_quiet$(OBJ) \
+  f128_lt_quiet$(OBJ) \
+  f128_isSignalingNaN$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Linux-RISCV64-GCC/platform.h b/softfloat/build/Linux-RISCV64-GCC/platform.h
new file mode 100644
index 0000000..c5e06f8
--- /dev/null
+++ b/softfloat/build/Linux-RISCV64-GCC/platform.h
@@ -0,0 +1,54 @@
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#define SOFTFLOAT_INTRINSIC_INT128 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Linux-x86_64-GCC/Makefile b/softfloat/build/Linux-x86_64-GCC/Makefile
index 5703378..72f251a 100644
--- a/softfloat/build/Linux-x86_64-GCC/Makefile
+++ b/softfloat/build/Linux-x86_64-GCC/Makefile
@@ -1,390 +1,397 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086-SSE
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
-    $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_eq128$(OBJ) \
-  s_le128$(OBJ) \
-  s_lt128$(OBJ) \
-  s_shortShiftLeft128$(OBJ) \
-  s_shortShiftRight128$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJam64Extra$(OBJ) \
-  s_shortShiftRightJam128$(OBJ) \
-  s_shortShiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJam64Extra$(OBJ) \
-  s_shiftRightJam128$(OBJ) \
-  s_shiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam256M$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_add128$(OBJ) \
-  s_add256M$(OBJ) \
-  s_sub128$(OBJ) \
-  s_sub256M$(OBJ) \
-  s_mul64ByShifted32To128$(OBJ) \
-  s_mul64To128$(OBJ) \
-  s_mul128By32$(OBJ) \
-  s_mul128To256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80UIToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80UI$(OBJ) \
-  s_propagateNaNExtF80UI$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128UIToCommonNaN$(OBJ) \
-  s_commonNaNToF128UI$(OBJ) \
-  s_propagateNaNF128UI$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_normSubnormalExtF80Sig$(OBJ) \
-  s_roundPackToExtF80$(OBJ) \
-  s_normRoundPackToExtF80$(OBJ) \
-  s_addMagsExtF80$(OBJ) \
-  s_subMagsExtF80$(OBJ) \
-  s_normSubnormalF128Sig$(OBJ) \
-  s_roundPackToF128$(OBJ) \
-  s_normRoundPackToF128$(OBJ) \
-  s_addMagsF128$(OBJ) \
-  s_subMagsF128$(OBJ) \
-  s_mulAddF128$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80_to_ui32$(OBJ) \
-  extF80_to_ui64$(OBJ) \
-  extF80_to_i32$(OBJ) \
-  extF80_to_i64$(OBJ) \
-  extF80_to_ui32_r_minMag$(OBJ) \
-  extF80_to_ui64_r_minMag$(OBJ) \
-  extF80_to_i32_r_minMag$(OBJ) \
-  extF80_to_i64_r_minMag$(OBJ) \
-  extF80_to_f16$(OBJ) \
-  extF80_to_f32$(OBJ) \
-  extF80_to_f64$(OBJ) \
-  extF80_to_f128$(OBJ) \
-  extF80_roundToInt$(OBJ) \
-  extF80_add$(OBJ) \
-  extF80_sub$(OBJ) \
-  extF80_mul$(OBJ) \
-  extF80_div$(OBJ) \
-  extF80_rem$(OBJ) \
-  extF80_sqrt$(OBJ) \
-  extF80_eq$(OBJ) \
-  extF80_le$(OBJ) \
-  extF80_lt$(OBJ) \
-  extF80_eq_signaling$(OBJ) \
-  extF80_le_quiet$(OBJ) \
-  extF80_lt_quiet$(OBJ) \
-  extF80_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128_to_ui32$(OBJ) \
-  f128_to_ui64$(OBJ) \
-  f128_to_i32$(OBJ) \
-  f128_to_i64$(OBJ) \
-  f128_to_ui32_r_minMag$(OBJ) \
-  f128_to_ui64_r_minMag$(OBJ) \
-  f128_to_i32_r_minMag$(OBJ) \
-  f128_to_i64_r_minMag$(OBJ) \
-  f128_to_f16$(OBJ) \
-  f128_to_f32$(OBJ) \
-  f128_to_extF80$(OBJ) \
-  f128_to_f64$(OBJ) \
-  f128_roundToInt$(OBJ) \
-  f128_add$(OBJ) \
-  f128_sub$(OBJ) \
-  f128_mul$(OBJ) \
-  f128_mulAdd$(OBJ) \
-  f128_div$(OBJ) \
-  f128_rem$(OBJ) \
-  f128_sqrt$(OBJ) \
-  f128_eq$(OBJ) \
-  f128_le$(OBJ) \
-  f128_lt$(OBJ) \
-  f128_eq_signaling$(OBJ) \
-  f128_le_quiet$(OBJ) \
-  f128_lt_quiet$(OBJ) \
-  f128_isSignalingNaN$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration -DSOFTFLOAT_FAST_INT64 \
+    $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_eq128$(OBJ) \
+  s_le128$(OBJ) \
+  s_lt128$(OBJ) \
+  s_shortShiftLeft128$(OBJ) \
+  s_shortShiftRight128$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJam64Extra$(OBJ) \
+  s_shortShiftRightJam128$(OBJ) \
+  s_shortShiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJam64Extra$(OBJ) \
+  s_shiftRightJam128$(OBJ) \
+  s_shiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam256M$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_add128$(OBJ) \
+  s_add256M$(OBJ) \
+  s_sub128$(OBJ) \
+  s_sub256M$(OBJ) \
+  s_mul64ByShifted32To128$(OBJ) \
+  s_mul64To128$(OBJ) \
+  s_mul128By32$(OBJ) \
+  s_mul128To256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_bf16UIToCommonNaN$(OBJ) \
+  s_commonNaNToBF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80UIToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80UI$(OBJ) \
+  s_propagateNaNExtF80UI$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128UIToCommonNaN$(OBJ) \
+  s_commonNaNToF128UI$(OBJ) \
+  s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundToI64$(OBJ) \
+  s_normSubnormalBF16Sig$(OBJ) \
+  s_roundPackToBF16$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_normSubnormalExtF80Sig$(OBJ) \
+  s_roundPackToExtF80$(OBJ) \
+  s_normRoundPackToExtF80$(OBJ) \
+  s_addMagsExtF80$(OBJ) \
+  s_subMagsExtF80$(OBJ) \
+  s_normSubnormalF128Sig$(OBJ) \
+  s_roundPackToF128$(OBJ) \
+  s_normRoundPackToF128$(OBJ) \
+  s_addMagsF128$(OBJ) \
+  s_subMagsF128$(OBJ) \
+  s_mulAddF128$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  bf16_isSignalingNaN$(OBJ) \
+  bf16_to_f32$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_bf16$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80_to_ui32$(OBJ) \
+  extF80_to_ui64$(OBJ) \
+  extF80_to_i32$(OBJ) \
+  extF80_to_i64$(OBJ) \
+  extF80_to_ui32_r_minMag$(OBJ) \
+  extF80_to_ui64_r_minMag$(OBJ) \
+  extF80_to_i32_r_minMag$(OBJ) \
+  extF80_to_i64_r_minMag$(OBJ) \
+  extF80_to_f16$(OBJ) \
+  extF80_to_f32$(OBJ) \
+  extF80_to_f64$(OBJ) \
+  extF80_to_f128$(OBJ) \
+  extF80_roundToInt$(OBJ) \
+  extF80_add$(OBJ) \
+  extF80_sub$(OBJ) \
+  extF80_mul$(OBJ) \
+  extF80_div$(OBJ) \
+  extF80_rem$(OBJ) \
+  extF80_sqrt$(OBJ) \
+  extF80_eq$(OBJ) \
+  extF80_le$(OBJ) \
+  extF80_lt$(OBJ) \
+  extF80_eq_signaling$(OBJ) \
+  extF80_le_quiet$(OBJ) \
+  extF80_lt_quiet$(OBJ) \
+  extF80_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128_to_ui32$(OBJ) \
+  f128_to_ui64$(OBJ) \
+  f128_to_i32$(OBJ) \
+  f128_to_i64$(OBJ) \
+  f128_to_ui32_r_minMag$(OBJ) \
+  f128_to_ui64_r_minMag$(OBJ) \
+  f128_to_i32_r_minMag$(OBJ) \
+  f128_to_i64_r_minMag$(OBJ) \
+  f128_to_f16$(OBJ) \
+  f128_to_f32$(OBJ) \
+  f128_to_extF80$(OBJ) \
+  f128_to_f64$(OBJ) \
+  f128_roundToInt$(OBJ) \
+  f128_add$(OBJ) \
+  f128_sub$(OBJ) \
+  f128_mul$(OBJ) \
+  f128_mulAdd$(OBJ) \
+  f128_div$(OBJ) \
+  f128_rem$(OBJ) \
+  f128_sqrt$(OBJ) \
+  f128_eq$(OBJ) \
+  f128_le$(OBJ) \
+  f128_lt$(OBJ) \
+  f128_eq_signaling$(OBJ) \
+  f128_le_quiet$(OBJ) \
+  f128_lt_quiet$(OBJ) \
+  f128_isSignalingNaN$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Linux-x86_64-GCC/platform.h b/softfloat/build/Linux-x86_64-GCC/platform.h
index 630cb43..cd1b5b4 100644
--- a/softfloat/build/Linux-x86_64-GCC/platform.h
+++ b/softfloat/build/Linux-x86_64-GCC/platform.h
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-//#define INLINE inline
-#define INLINE static
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC__
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#define SOFTFLOAT_INTRINSIC_INT128 1
-#endif
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+//#define INLINE inline
+#define INLINE static
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+#ifdef __GNUC__
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#define SOFTFLOAT_INTRINSIC_INT128 1
+#endif
+#include "opts-GCC.h"
diff --git a/softfloat/build/Win32-MinGW/Makefile b/softfloat/build/Win32-MinGW/Makefile
index 4181600..faeb397 100644
--- a/softfloat/build/Win32-MinGW/Makefile
+++ b/softfloat/build/Win32-MinGW/Makefile
@@ -1,325 +1,325 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
-    $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+    $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Win32-MinGW/platform.h b/softfloat/build/Win32-MinGW/platform.h
index eb224b1..d514dbc 100644
--- a/softfloat/build/Win32-MinGW/platform.h
+++ b/softfloat/build/Win32-MinGW/platform.h
@@ -1,52 +1,53 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Win32-SSE2-MinGW/Makefile b/softfloat/build/Win32-SSE2-MinGW/Makefile
index 1cf6f5e..ced977b 100644
--- a/softfloat/build/Win32-SSE2-MinGW/Makefile
+++ b/softfloat/build/Win32-SSE2-MinGW/Makefile
@@ -1,325 +1,325 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086-SSE
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
-    $(C_INCLUDES) -O2 -o $@
-MAKELIB = ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  gcc -c -Werror-implicit-function-declaration $(SOFTFLOAT_OPTS) \
+    $(C_INCLUDES) -O2 -o $@
+MAKELIB = ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Win32-SSE2-MinGW/platform.h b/softfloat/build/Win32-SSE2-MinGW/platform.h
index eb224b1..d514dbc 100644
--- a/softfloat/build/Win32-SSE2-MinGW/platform.h
+++ b/softfloat/build/Win32-SSE2-MinGW/platform.h
@@ -1,52 +1,53 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/Win64-MinGW-w64/Makefile b/softfloat/build/Win64-MinGW-w64/Makefile
index 05bbf5b..cc5bc0c 100644
--- a/softfloat/build/Win64-MinGW-w64/Makefile
+++ b/softfloat/build/Win64-MinGW-w64/Makefile
@@ -1,390 +1,390 @@
-
-#=============================================================================
-#
-# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
-# Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-SOURCE_DIR ?= ../../source
-SPECIALIZE_TYPE ?= 8086-SSE
-
-SOFTFLOAT_OPTS ?= \
-  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-  -DSOFTFLOAT_FAST_DIV64TO32
-
-DELETE = rm -f
-C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-COMPILE_C = \
-  x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \
-    -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
-MAKELIB = x86_64-w64-mingw32-ar crs $@
-
-OBJ = .o
-LIB = .a
-
-OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_eq128$(OBJ) \
-  s_le128$(OBJ) \
-  s_lt128$(OBJ) \
-  s_shortShiftLeft128$(OBJ) \
-  s_shortShiftRight128$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJam64Extra$(OBJ) \
-  s_shortShiftRightJam128$(OBJ) \
-  s_shortShiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJam64Extra$(OBJ) \
-  s_shiftRightJam128$(OBJ) \
-  s_shiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam256M$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_add128$(OBJ) \
-  s_add256M$(OBJ) \
-  s_sub128$(OBJ) \
-  s_sub256M$(OBJ) \
-  s_mul64ByShifted32To128$(OBJ) \
-  s_mul64To128$(OBJ) \
-  s_mul128By32$(OBJ) \
-  s_mul128To256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80UIToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80UI$(OBJ) \
-  s_propagateNaNExtF80UI$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128UIToCommonNaN$(OBJ) \
-  s_commonNaNToF128UI$(OBJ) \
-  s_propagateNaNF128UI$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_normSubnormalExtF80Sig$(OBJ) \
-  s_roundPackToExtF80$(OBJ) \
-  s_normRoundPackToExtF80$(OBJ) \
-  s_addMagsExtF80$(OBJ) \
-  s_subMagsExtF80$(OBJ) \
-  s_normSubnormalF128Sig$(OBJ) \
-  s_roundPackToF128$(OBJ) \
-  s_normRoundPackToF128$(OBJ) \
-  s_addMagsF128$(OBJ) \
-  s_subMagsF128$(OBJ) \
-  s_mulAddF128$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80_to_ui32$(OBJ) \
-  extF80_to_ui64$(OBJ) \
-  extF80_to_i32$(OBJ) \
-  extF80_to_i64$(OBJ) \
-  extF80_to_ui32_r_minMag$(OBJ) \
-  extF80_to_ui64_r_minMag$(OBJ) \
-  extF80_to_i32_r_minMag$(OBJ) \
-  extF80_to_i64_r_minMag$(OBJ) \
-  extF80_to_f16$(OBJ) \
-  extF80_to_f32$(OBJ) \
-  extF80_to_f64$(OBJ) \
-  extF80_to_f128$(OBJ) \
-  extF80_roundToInt$(OBJ) \
-  extF80_add$(OBJ) \
-  extF80_sub$(OBJ) \
-  extF80_mul$(OBJ) \
-  extF80_div$(OBJ) \
-  extF80_rem$(OBJ) \
-  extF80_sqrt$(OBJ) \
-  extF80_eq$(OBJ) \
-  extF80_le$(OBJ) \
-  extF80_lt$(OBJ) \
-  extF80_eq_signaling$(OBJ) \
-  extF80_le_quiet$(OBJ) \
-  extF80_lt_quiet$(OBJ) \
-  extF80_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128_to_ui32$(OBJ) \
-  f128_to_ui64$(OBJ) \
-  f128_to_i32$(OBJ) \
-  f128_to_i64$(OBJ) \
-  f128_to_ui32_r_minMag$(OBJ) \
-  f128_to_ui64_r_minMag$(OBJ) \
-  f128_to_i32_r_minMag$(OBJ) \
-  f128_to_i64_r_minMag$(OBJ) \
-  f128_to_f16$(OBJ) \
-  f128_to_f32$(OBJ) \
-  f128_to_extF80$(OBJ) \
-  f128_to_f64$(OBJ) \
-  f128_roundToInt$(OBJ) \
-  f128_add$(OBJ) \
-  f128_sub$(OBJ) \
-  f128_mul$(OBJ) \
-  f128_mulAdd$(OBJ) \
-  f128_div$(OBJ) \
-  f128_rem$(OBJ) \
-  f128_sqrt$(OBJ) \
-  f128_eq$(OBJ) \
-  f128_le$(OBJ) \
-  f128_lt$(OBJ) \
-  f128_eq_signaling$(OBJ) \
-  f128_le_quiet$(OBJ) \
-  f128_lt_quiet$(OBJ) \
-  f128_isSignalingNaN$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile is part of the SoftFloat IEEE Floating-Point Arithmetic
+# Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+SOURCE_DIR ?= ../../source
+SPECIALIZE_TYPE ?= 8086-SSE
+
+SOFTFLOAT_OPTS ?= \
+  -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+  -DSOFTFLOAT_FAST_DIV64TO32
+
+DELETE = rm -f
+C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+COMPILE_C = \
+  x86_64-w64-mingw32-gcc -c -Werror-implicit-function-declaration \
+    -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+MAKELIB = x86_64-w64-mingw32-ar crs $@
+
+OBJ = .o
+LIB = .a
+
+OTHER_HEADERS = $(SOURCE_DIR)/include/opts-GCC.h
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_eq128$(OBJ) \
+  s_le128$(OBJ) \
+  s_lt128$(OBJ) \
+  s_shortShiftLeft128$(OBJ) \
+  s_shortShiftRight128$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJam64Extra$(OBJ) \
+  s_shortShiftRightJam128$(OBJ) \
+  s_shortShiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJam64Extra$(OBJ) \
+  s_shiftRightJam128$(OBJ) \
+  s_shiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam256M$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_add128$(OBJ) \
+  s_add256M$(OBJ) \
+  s_sub128$(OBJ) \
+  s_sub256M$(OBJ) \
+  s_mul64ByShifted32To128$(OBJ) \
+  s_mul64To128$(OBJ) \
+  s_mul128By32$(OBJ) \
+  s_mul128To256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80UIToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80UI$(OBJ) \
+  s_propagateNaNExtF80UI$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128UIToCommonNaN$(OBJ) \
+  s_commonNaNToF128UI$(OBJ) \
+  s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_normSubnormalExtF80Sig$(OBJ) \
+  s_roundPackToExtF80$(OBJ) \
+  s_normRoundPackToExtF80$(OBJ) \
+  s_addMagsExtF80$(OBJ) \
+  s_subMagsExtF80$(OBJ) \
+  s_normSubnormalF128Sig$(OBJ) \
+  s_roundPackToF128$(OBJ) \
+  s_normRoundPackToF128$(OBJ) \
+  s_addMagsF128$(OBJ) \
+  s_subMagsF128$(OBJ) \
+  s_mulAddF128$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80_to_ui32$(OBJ) \
+  extF80_to_ui64$(OBJ) \
+  extF80_to_i32$(OBJ) \
+  extF80_to_i64$(OBJ) \
+  extF80_to_ui32_r_minMag$(OBJ) \
+  extF80_to_ui64_r_minMag$(OBJ) \
+  extF80_to_i32_r_minMag$(OBJ) \
+  extF80_to_i64_r_minMag$(OBJ) \
+  extF80_to_f16$(OBJ) \
+  extF80_to_f32$(OBJ) \
+  extF80_to_f64$(OBJ) \
+  extF80_to_f128$(OBJ) \
+  extF80_roundToInt$(OBJ) \
+  extF80_add$(OBJ) \
+  extF80_sub$(OBJ) \
+  extF80_mul$(OBJ) \
+  extF80_div$(OBJ) \
+  extF80_rem$(OBJ) \
+  extF80_sqrt$(OBJ) \
+  extF80_eq$(OBJ) \
+  extF80_le$(OBJ) \
+  extF80_lt$(OBJ) \
+  extF80_eq_signaling$(OBJ) \
+  extF80_le_quiet$(OBJ) \
+  extF80_lt_quiet$(OBJ) \
+  extF80_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128_to_ui32$(OBJ) \
+  f128_to_ui64$(OBJ) \
+  f128_to_i32$(OBJ) \
+  f128_to_i64$(OBJ) \
+  f128_to_ui32_r_minMag$(OBJ) \
+  f128_to_ui64_r_minMag$(OBJ) \
+  f128_to_i32_r_minMag$(OBJ) \
+  f128_to_i64_r_minMag$(OBJ) \
+  f128_to_f16$(OBJ) \
+  f128_to_f32$(OBJ) \
+  f128_to_extF80$(OBJ) \
+  f128_to_f64$(OBJ) \
+  f128_roundToInt$(OBJ) \
+  f128_add$(OBJ) \
+  f128_sub$(OBJ) \
+  f128_mul$(OBJ) \
+  f128_mulAdd$(OBJ) \
+  f128_div$(OBJ) \
+  f128_rem$(OBJ) \
+  f128_sqrt$(OBJ) \
+  f128_eq$(OBJ) \
+  f128_le$(OBJ) \
+  f128_lt$(OBJ) \
+  f128_eq_signaling$(OBJ) \
+  f128_le_quiet$(OBJ) \
+  f128_lt_quiet$(OBJ) \
+  f128_isSignalingNaN$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/Win64-MinGW-w64/platform.h b/softfloat/build/Win64-MinGW-w64/platform.h
index 737a708..c5e06f8 100644
--- a/softfloat/build/Win64-MinGW-w64/platform.h
+++ b/softfloat/build/Win64-MinGW-w64/platform.h
@@ -1,53 +1,54 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define LITTLEENDIAN 1
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#ifdef __GNUC_STDC_INLINE__
-#define INLINE inline
-#else
-#define INLINE extern inline
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define SOFTFLOAT_BUILTIN_CLZ 1
-#define SOFTFLOAT_INTRINSIC_INT128 1
-#include "opts-GCC.h"
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#ifdef __GNUC_STDC_INLINE__
+#define INLINE inline
+#else
+#define INLINE extern inline
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define SOFTFLOAT_BUILTIN_CLZ 1
+#define SOFTFLOAT_INTRINSIC_INT128 1
+#include "opts-GCC.h"
+
diff --git a/softfloat/build/template-FAST_INT64/Makefile b/softfloat/build/template-FAST_INT64/Makefile
index c5005e6..e04c216 100644
--- a/softfloat/build/template-FAST_INT64/Makefile
+++ b/softfloat/build/template-FAST_INT64/Makefile
@@ -1,391 +1,396 @@
-
-#=============================================================================
-#
-# This Makefile template is part of the SoftFloat IEEE Floating-Point
-# Arithmetic Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-# Edit lines marked with `==>'.  See "SoftFloat-source.html".
-
-==> SOURCE_DIR ?= ../../source
-==> SPECIALIZE_TYPE ?= 8086
-
-==> SOFTFLOAT_OPTS ?= \
-==>   -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-==>   -DSOFTFLOAT_FAST_DIV64TO32
-
-==> DELETE = rm -f
-==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-==> COMPILE_C = \
-==>   cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
-==> MAKELIB = ar crs $@
-
-==> OBJ = .o
-==> LIB = .a
-
-==> OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_eq128$(OBJ) \
-  s_le128$(OBJ) \
-  s_lt128$(OBJ) \
-  s_shortShiftLeft128$(OBJ) \
-  s_shortShiftRight128$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJam64Extra$(OBJ) \
-  s_shortShiftRightJam128$(OBJ) \
-  s_shortShiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJam64Extra$(OBJ) \
-  s_shiftRightJam128$(OBJ) \
-  s_shiftRightJam128Extra$(OBJ) \
-  s_shiftRightJam256M$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_add128$(OBJ) \
-  s_add256M$(OBJ) \
-  s_sub128$(OBJ) \
-  s_sub256M$(OBJ) \
-  s_mul64ByShifted32To128$(OBJ) \
-  s_mul64To128$(OBJ) \
-  s_mul128By32$(OBJ) \
-  s_mul128To256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80UIToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80UI$(OBJ) \
-  s_propagateNaNExtF80UI$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128UIToCommonNaN$(OBJ) \
-  s_commonNaNToF128UI$(OBJ) \
-  s_propagateNaNF128UI$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_normSubnormalExtF80Sig$(OBJ) \
-  s_roundPackToExtF80$(OBJ) \
-  s_normRoundPackToExtF80$(OBJ) \
-  s_addMagsExtF80$(OBJ) \
-  s_subMagsExtF80$(OBJ) \
-  s_normSubnormalF128Sig$(OBJ) \
-  s_roundPackToF128$(OBJ) \
-  s_normRoundPackToF128$(OBJ) \
-  s_addMagsF128$(OBJ) \
-  s_subMagsF128$(OBJ) \
-  s_mulAddF128$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80_to_ui32$(OBJ) \
-  extF80_to_ui64$(OBJ) \
-  extF80_to_i32$(OBJ) \
-  extF80_to_i64$(OBJ) \
-  extF80_to_ui32_r_minMag$(OBJ) \
-  extF80_to_ui64_r_minMag$(OBJ) \
-  extF80_to_i32_r_minMag$(OBJ) \
-  extF80_to_i64_r_minMag$(OBJ) \
-  extF80_to_f16$(OBJ) \
-  extF80_to_f32$(OBJ) \
-  extF80_to_f64$(OBJ) \
-  extF80_to_f128$(OBJ) \
-  extF80_roundToInt$(OBJ) \
-  extF80_add$(OBJ) \
-  extF80_sub$(OBJ) \
-  extF80_mul$(OBJ) \
-  extF80_div$(OBJ) \
-  extF80_rem$(OBJ) \
-  extF80_sqrt$(OBJ) \
-  extF80_eq$(OBJ) \
-  extF80_le$(OBJ) \
-  extF80_lt$(OBJ) \
-  extF80_eq_signaling$(OBJ) \
-  extF80_le_quiet$(OBJ) \
-  extF80_lt_quiet$(OBJ) \
-  extF80_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128_to_ui32$(OBJ) \
-  f128_to_ui64$(OBJ) \
-  f128_to_i32$(OBJ) \
-  f128_to_i64$(OBJ) \
-  f128_to_ui32_r_minMag$(OBJ) \
-  f128_to_ui64_r_minMag$(OBJ) \
-  f128_to_i32_r_minMag$(OBJ) \
-  f128_to_i64_r_minMag$(OBJ) \
-  f128_to_f16$(OBJ) \
-  f128_to_f32$(OBJ) \
-  f128_to_extF80$(OBJ) \
-  f128_to_f64$(OBJ) \
-  f128_roundToInt$(OBJ) \
-  f128_add$(OBJ) \
-  f128_sub$(OBJ) \
-  f128_mul$(OBJ) \
-  f128_mulAdd$(OBJ) \
-  f128_div$(OBJ) \
-  f128_rem$(OBJ) \
-  f128_sqrt$(OBJ) \
-  f128_eq$(OBJ) \
-  f128_le$(OBJ) \
-  f128_lt$(OBJ) \
-  f128_eq_signaling$(OBJ) \
-  f128_le_quiet$(OBJ) \
-  f128_lt_quiet$(OBJ) \
-  f128_isSignalingNaN$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile template is part of the SoftFloat IEEE Floating-Point
+# Arithmetic Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+# Edit lines marked with `==>'.  See "SoftFloat-source.html".
+
+==> SOURCE_DIR ?= ../../source
+==> SPECIALIZE_TYPE ?= 8086
+
+==> SOFTFLOAT_OPTS ?= \
+==>   -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+==>   -DSOFTFLOAT_FAST_DIV64TO32
+
+==> DELETE = rm -f
+==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+==> COMPILE_C = \
+==>   cc -c -DSOFTFLOAT_FAST_INT64 $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+==> MAKELIB = ar crs $@
+
+==> OBJ = .o
+==> LIB = .a
+
+==> OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_eq128$(OBJ) \
+  s_le128$(OBJ) \
+  s_lt128$(OBJ) \
+  s_shortShiftLeft128$(OBJ) \
+  s_shortShiftRight128$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJam64Extra$(OBJ) \
+  s_shortShiftRightJam128$(OBJ) \
+  s_shortShiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJam64Extra$(OBJ) \
+  s_shiftRightJam128$(OBJ) \
+  s_shiftRightJam128Extra$(OBJ) \
+  s_shiftRightJam256M$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_add128$(OBJ) \
+  s_add256M$(OBJ) \
+  s_sub128$(OBJ) \
+  s_sub256M$(OBJ) \
+  s_mul64ByShifted32To128$(OBJ) \
+  s_mul64To128$(OBJ) \
+  s_mul128By32$(OBJ) \
+  s_mul128To256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80UIToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80UI$(OBJ) \
+  s_propagateNaNExtF80UI$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128UIToCommonNaN$(OBJ) \
+  s_commonNaNToF128UI$(OBJ) \
+  s_propagateNaNF128UI$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundToI64$(OBJ) \
+  s_normSubnormalBF16Sig$(OBJ) \
+  s_roundPackToBF16$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_normSubnormalExtF80Sig$(OBJ) \
+  s_roundPackToExtF80$(OBJ) \
+  s_normRoundPackToExtF80$(OBJ) \
+  s_addMagsExtF80$(OBJ) \
+  s_subMagsExtF80$(OBJ) \
+  s_normSubnormalF128Sig$(OBJ) \
+  s_roundPackToF128$(OBJ) \
+  s_normRoundPackToF128$(OBJ) \
+  s_addMagsF128$(OBJ) \
+  s_subMagsF128$(OBJ) \
+  s_mulAddF128$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  bf16_isSignalingNaN$(OBJ) \
+  bf16_to_f32$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_bf16$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80_to_ui32$(OBJ) \
+  extF80_to_ui64$(OBJ) \
+  extF80_to_i32$(OBJ) \
+  extF80_to_i64$(OBJ) \
+  extF80_to_ui32_r_minMag$(OBJ) \
+  extF80_to_ui64_r_minMag$(OBJ) \
+  extF80_to_i32_r_minMag$(OBJ) \
+  extF80_to_i64_r_minMag$(OBJ) \
+  extF80_to_f16$(OBJ) \
+  extF80_to_f32$(OBJ) \
+  extF80_to_f64$(OBJ) \
+  extF80_to_f128$(OBJ) \
+  extF80_roundToInt$(OBJ) \
+  extF80_add$(OBJ) \
+  extF80_sub$(OBJ) \
+  extF80_mul$(OBJ) \
+  extF80_div$(OBJ) \
+  extF80_rem$(OBJ) \
+  extF80_sqrt$(OBJ) \
+  extF80_eq$(OBJ) \
+  extF80_le$(OBJ) \
+  extF80_lt$(OBJ) \
+  extF80_eq_signaling$(OBJ) \
+  extF80_le_quiet$(OBJ) \
+  extF80_lt_quiet$(OBJ) \
+  extF80_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128_to_ui32$(OBJ) \
+  f128_to_ui64$(OBJ) \
+  f128_to_i32$(OBJ) \
+  f128_to_i64$(OBJ) \
+  f128_to_ui32_r_minMag$(OBJ) \
+  f128_to_ui64_r_minMag$(OBJ) \
+  f128_to_i32_r_minMag$(OBJ) \
+  f128_to_i64_r_minMag$(OBJ) \
+  f128_to_f16$(OBJ) \
+  f128_to_f32$(OBJ) \
+  f128_to_extF80$(OBJ) \
+  f128_to_f64$(OBJ) \
+  f128_roundToInt$(OBJ) \
+  f128_add$(OBJ) \
+  f128_sub$(OBJ) \
+  f128_mul$(OBJ) \
+  f128_mulAdd$(OBJ) \
+  f128_div$(OBJ) \
+  f128_rem$(OBJ) \
+  f128_sqrt$(OBJ) \
+  f128_eq$(OBJ) \
+  f128_le$(OBJ) \
+  f128_lt$(OBJ) \
+  f128_eq_signaling$(OBJ) \
+  f128_le_quiet$(OBJ) \
+  f128_lt_quiet$(OBJ) \
+  f128_isSignalingNaN$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/template-FAST_INT64/platform.h b/softfloat/build/template-FAST_INT64/platform.h
index b59e6c5..2094658 100644
--- a/softfloat/build/template-FAST_INT64/platform.h
+++ b/softfloat/build/template-FAST_INT64/platform.h
@@ -1,49 +1,50 @@
-
-/*============================================================================
-
-This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-// Edit lines marked with `==>'.  See "SoftFloat-source.html".
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-== > #define LITTLEENDIAN 1
-
-    /*----------------------------------------------------------------------------
-     *----------------------------------------------------------------------------*/
-    == > #define INLINE inline
-
-    /*----------------------------------------------------------------------------
-     *----------------------------------------------------------------------------*/
-    == > #define THREAD_LOCAL _Thread_local
+
+/*============================================================================
+
+This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+// Edit lines marked with `==>'.  See "SoftFloat-source.html".
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define INLINE inline
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define THREAD_LOCAL _Thread_local
+
diff --git a/softfloat/build/template-not-FAST_INT64/Makefile b/softfloat/build/template-not-FAST_INT64/Makefile
index 49fddfd..48b2cd6 100644
--- a/softfloat/build/template-not-FAST_INT64/Makefile
+++ b/softfloat/build/template-not-FAST_INT64/Makefile
@@ -1,325 +1,325 @@
-
-#=============================================================================
-#
-# This Makefile template is part of the SoftFloat IEEE Floating-Point
-# Arithmetic Package, Release 3e, by John R. Hauser.
-#
-# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-# University of California.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-#  1. Redistributions of source code must retain the above copyright notice,
-#     this list of conditions, and the following disclaimer.
-#
-#  2. Redistributions in binary form must reproduce the above copyright
-#     notice, this list of conditions, and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution.
-#
-#  3. Neither the name of the University nor the names of its contributors
-#     may be used to endorse or promote products derived from this software
-#     without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#
-#=============================================================================
-
-# Edit lines marked with `==>'.  See "SoftFloat-source.html".
-
-==> SOURCE_DIR ?= ../../source
-==> SPECIALIZE_TYPE ?= 8086
-
-==> SOFTFLOAT_OPTS ?= \
-==>   -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
-==>   -DSOFTFLOAT_FAST_DIV64TO32
-
-==> DELETE = rm -f
-==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
-==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
-==> MAKELIB = ar crs $@
-
-==> OBJ = .o
-==> LIB = .a
-
-==> OTHER_HEADERS =
-
-.PHONY: all
-all: softfloat$(LIB)
-
-OBJS_PRIMITIVES = \
-  s_compare96M$(OBJ) \
-  s_compare128M$(OBJ) \
-  s_shortShiftLeft64To96M$(OBJ) \
-  s_shortShiftLeftM$(OBJ) \
-  s_shiftLeftM$(OBJ) \
-  s_shortShiftRightM$(OBJ) \
-  s_shortShiftRightJam64$(OBJ) \
-  s_shortShiftRightJamM$(OBJ) \
-  s_shiftRightJam32$(OBJ) \
-  s_shiftRightJam64$(OBJ) \
-  s_shiftRightJamM$(OBJ) \
-  s_shiftRightM$(OBJ) \
-  s_countLeadingZeros8$(OBJ) \
-  s_countLeadingZeros16$(OBJ) \
-  s_countLeadingZeros32$(OBJ) \
-  s_countLeadingZeros64$(OBJ) \
-  s_addM$(OBJ) \
-  s_addCarryM$(OBJ) \
-  s_addComplCarryM$(OBJ) \
-  s_negXM$(OBJ) \
-  s_sub1XM$(OBJ) \
-  s_subM$(OBJ) \
-  s_mul64To128M$(OBJ) \
-  s_mul128MTo256M$(OBJ) \
-  s_approxRecip_1Ks$(OBJ) \
-  s_approxRecip32_1$(OBJ) \
-  s_approxRecipSqrt_1Ks$(OBJ) \
-  s_approxRecipSqrt32_1$(OBJ) \
-  s_remStepMBy32$(OBJ) \
-
-OBJS_SPECIALIZE = \
-  softfloat_raiseFlags$(OBJ) \
-  s_f16UIToCommonNaN$(OBJ) \
-  s_commonNaNToF16UI$(OBJ) \
-  s_propagateNaNF16UI$(OBJ) \
-  s_f32UIToCommonNaN$(OBJ) \
-  s_commonNaNToF32UI$(OBJ) \
-  s_propagateNaNF32UI$(OBJ) \
-  s_f64UIToCommonNaN$(OBJ) \
-  s_commonNaNToF64UI$(OBJ) \
-  s_propagateNaNF64UI$(OBJ) \
-  extF80M_isSignalingNaN$(OBJ) \
-  s_extF80MToCommonNaN$(OBJ) \
-  s_commonNaNToExtF80M$(OBJ) \
-  s_propagateNaNExtF80M$(OBJ) \
-  f128M_isSignalingNaN$(OBJ) \
-  s_f128MToCommonNaN$(OBJ) \
-  s_commonNaNToF128M$(OBJ) \
-  s_propagateNaNF128M$(OBJ) \
-
-OBJS_OTHERS = \
-  s_roundToUI32$(OBJ) \
-  s_roundMToUI64$(OBJ) \
-  s_roundToI32$(OBJ) \
-  s_roundMToI64$(OBJ) \
-  s_normSubnormalF16Sig$(OBJ) \
-  s_roundPackToF16$(OBJ) \
-  s_normRoundPackToF16$(OBJ) \
-  s_addMagsF16$(OBJ) \
-  s_subMagsF16$(OBJ) \
-  s_mulAddF16$(OBJ) \
-  s_normSubnormalF32Sig$(OBJ) \
-  s_roundPackToF32$(OBJ) \
-  s_normRoundPackToF32$(OBJ) \
-  s_addMagsF32$(OBJ) \
-  s_subMagsF32$(OBJ) \
-  s_mulAddF32$(OBJ) \
-  s_normSubnormalF64Sig$(OBJ) \
-  s_roundPackToF64$(OBJ) \
-  s_normRoundPackToF64$(OBJ) \
-  s_addMagsF64$(OBJ) \
-  s_subMagsF64$(OBJ) \
-  s_mulAddF64$(OBJ) \
-  s_tryPropagateNaNExtF80M$(OBJ) \
-  s_invalidExtF80M$(OBJ) \
-  s_normExtF80SigM$(OBJ) \
-  s_roundPackMToExtF80M$(OBJ) \
-  s_normRoundPackMToExtF80M$(OBJ) \
-  s_addExtF80M$(OBJ) \
-  s_compareNonnormExtF80M$(OBJ) \
-  s_isNaNF128M$(OBJ) \
-  s_tryPropagateNaNF128M$(OBJ) \
-  s_invalidF128M$(OBJ) \
-  s_shiftNormSigF128M$(OBJ) \
-  s_roundPackMToF128M$(OBJ) \
-  s_normRoundPackMToF128M$(OBJ) \
-  s_addF128M$(OBJ) \
-  s_mulAddF128M$(OBJ) \
-  softfloat_state$(OBJ) \
-  ui32_to_f16$(OBJ) \
-  ui32_to_f32$(OBJ) \
-  ui32_to_f64$(OBJ) \
-  ui32_to_extF80M$(OBJ) \
-  ui32_to_f128M$(OBJ) \
-  ui64_to_f16$(OBJ) \
-  ui64_to_f32$(OBJ) \
-  ui64_to_f64$(OBJ) \
-  ui64_to_extF80M$(OBJ) \
-  ui64_to_f128M$(OBJ) \
-  i32_to_f16$(OBJ) \
-  i32_to_f32$(OBJ) \
-  i32_to_f64$(OBJ) \
-  i32_to_extF80M$(OBJ) \
-  i32_to_f128M$(OBJ) \
-  i64_to_f16$(OBJ) \
-  i64_to_f32$(OBJ) \
-  i64_to_f64$(OBJ) \
-  i64_to_extF80M$(OBJ) \
-  i64_to_f128M$(OBJ) \
-  f16_to_ui32$(OBJ) \
-  f16_to_ui64$(OBJ) \
-  f16_to_i32$(OBJ) \
-  f16_to_i64$(OBJ) \
-  f16_to_ui32_r_minMag$(OBJ) \
-  f16_to_ui64_r_minMag$(OBJ) \
-  f16_to_i32_r_minMag$(OBJ) \
-  f16_to_i64_r_minMag$(OBJ) \
-  f16_to_f32$(OBJ) \
-  f16_to_f64$(OBJ) \
-  f16_to_extF80M$(OBJ) \
-  f16_to_f128M$(OBJ) \
-  f16_roundToInt$(OBJ) \
-  f16_add$(OBJ) \
-  f16_sub$(OBJ) \
-  f16_mul$(OBJ) \
-  f16_mulAdd$(OBJ) \
-  f16_div$(OBJ) \
-  f16_rem$(OBJ) \
-  f16_sqrt$(OBJ) \
-  f16_eq$(OBJ) \
-  f16_le$(OBJ) \
-  f16_lt$(OBJ) \
-  f16_eq_signaling$(OBJ) \
-  f16_le_quiet$(OBJ) \
-  f16_lt_quiet$(OBJ) \
-  f16_isSignalingNaN$(OBJ) \
-  f32_to_ui32$(OBJ) \
-  f32_to_ui64$(OBJ) \
-  f32_to_i32$(OBJ) \
-  f32_to_i64$(OBJ) \
-  f32_to_ui32_r_minMag$(OBJ) \
-  f32_to_ui64_r_minMag$(OBJ) \
-  f32_to_i32_r_minMag$(OBJ) \
-  f32_to_i64_r_minMag$(OBJ) \
-  f32_to_f16$(OBJ) \
-  f32_to_f64$(OBJ) \
-  f32_to_extF80M$(OBJ) \
-  f32_to_f128M$(OBJ) \
-  f32_roundToInt$(OBJ) \
-  f32_add$(OBJ) \
-  f32_sub$(OBJ) \
-  f32_mul$(OBJ) \
-  f32_mulAdd$(OBJ) \
-  f32_div$(OBJ) \
-  f32_rem$(OBJ) \
-  f32_sqrt$(OBJ) \
-  f32_eq$(OBJ) \
-  f32_le$(OBJ) \
-  f32_lt$(OBJ) \
-  f32_eq_signaling$(OBJ) \
-  f32_le_quiet$(OBJ) \
-  f32_lt_quiet$(OBJ) \
-  f32_isSignalingNaN$(OBJ) \
-  f64_to_ui32$(OBJ) \
-  f64_to_ui64$(OBJ) \
-  f64_to_i32$(OBJ) \
-  f64_to_i64$(OBJ) \
-  f64_to_ui32_r_minMag$(OBJ) \
-  f64_to_ui64_r_minMag$(OBJ) \
-  f64_to_i32_r_minMag$(OBJ) \
-  f64_to_i64_r_minMag$(OBJ) \
-  f64_to_f16$(OBJ) \
-  f64_to_f32$(OBJ) \
-  f64_to_extF80M$(OBJ) \
-  f64_to_f128M$(OBJ) \
-  f64_roundToInt$(OBJ) \
-  f64_add$(OBJ) \
-  f64_sub$(OBJ) \
-  f64_mul$(OBJ) \
-  f64_mulAdd$(OBJ) \
-  f64_div$(OBJ) \
-  f64_rem$(OBJ) \
-  f64_sqrt$(OBJ) \
-  f64_eq$(OBJ) \
-  f64_le$(OBJ) \
-  f64_lt$(OBJ) \
-  f64_eq_signaling$(OBJ) \
-  f64_le_quiet$(OBJ) \
-  f64_lt_quiet$(OBJ) \
-  f64_isSignalingNaN$(OBJ) \
-  extF80M_to_ui32$(OBJ) \
-  extF80M_to_ui64$(OBJ) \
-  extF80M_to_i32$(OBJ) \
-  extF80M_to_i64$(OBJ) \
-  extF80M_to_ui32_r_minMag$(OBJ) \
-  extF80M_to_ui64_r_minMag$(OBJ) \
-  extF80M_to_i32_r_minMag$(OBJ) \
-  extF80M_to_i64_r_minMag$(OBJ) \
-  extF80M_to_f16$(OBJ) \
-  extF80M_to_f32$(OBJ) \
-  extF80M_to_f64$(OBJ) \
-  extF80M_to_f128M$(OBJ) \
-  extF80M_roundToInt$(OBJ) \
-  extF80M_add$(OBJ) \
-  extF80M_sub$(OBJ) \
-  extF80M_mul$(OBJ) \
-  extF80M_div$(OBJ) \
-  extF80M_rem$(OBJ) \
-  extF80M_sqrt$(OBJ) \
-  extF80M_eq$(OBJ) \
-  extF80M_le$(OBJ) \
-  extF80M_lt$(OBJ) \
-  extF80M_eq_signaling$(OBJ) \
-  extF80M_le_quiet$(OBJ) \
-  extF80M_lt_quiet$(OBJ) \
-  f128M_to_ui32$(OBJ) \
-  f128M_to_ui64$(OBJ) \
-  f128M_to_i32$(OBJ) \
-  f128M_to_i64$(OBJ) \
-  f128M_to_ui32_r_minMag$(OBJ) \
-  f128M_to_ui64_r_minMag$(OBJ) \
-  f128M_to_i32_r_minMag$(OBJ) \
-  f128M_to_i64_r_minMag$(OBJ) \
-  f128M_to_f16$(OBJ) \
-  f128M_to_f32$(OBJ) \
-  f128M_to_f64$(OBJ) \
-  f128M_to_extF80M$(OBJ) \
-  f128M_roundToInt$(OBJ) \
-  f128M_add$(OBJ) \
-  f128M_sub$(OBJ) \
-  f128M_mul$(OBJ) \
-  f128M_mulAdd$(OBJ) \
-  f128M_div$(OBJ) \
-  f128M_rem$(OBJ) \
-  f128M_sqrt$(OBJ) \
-  f128M_eq$(OBJ) \
-  f128M_le$(OBJ) \
-  f128M_lt$(OBJ) \
-  f128M_eq_signaling$(OBJ) \
-  f128M_le_quiet$(OBJ) \
-  f128M_lt_quiet$(OBJ) \
-
-OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
-
-$(OBJS_ALL): \
-  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
-  $(SOURCE_DIR)/include/primitives.h
-$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
-  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
-  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
-  $(SOURCE_DIR)/include/softfloat.h
-
-$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$*.c
-
-$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
-	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
-
-softfloat$(LIB): $(OBJS_ALL)
-	$(DELETE) $@
-	$(MAKELIB) $^
-
-.PHONY: clean
-clean:
-	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
-
+
+#=============================================================================
+#
+# This Makefile template is part of the SoftFloat IEEE Floating-Point
+# Arithmetic Package, Release 3e, by John R. Hauser.
+#
+# Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+# University of California.  All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#  1. Redistributions of source code must retain the above copyright notice,
+#     this list of conditions, and the following disclaimer.
+#
+#  2. Redistributions in binary form must reproduce the above copyright
+#     notice, this list of conditions, and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#
+#  3. Neither the name of the University nor the names of its contributors
+#     may be used to endorse or promote products derived from this software
+#     without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+# DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+#=============================================================================
+
+# Edit lines marked with `==>'.  See "SoftFloat-source.html".
+
+==> SOURCE_DIR ?= ../../source
+==> SPECIALIZE_TYPE ?= 8086
+
+==> SOFTFLOAT_OPTS ?= \
+==>   -DSOFTFLOAT_ROUND_ODD -DINLINE_LEVEL=5 -DSOFTFLOAT_FAST_DIV32TO16 \
+==>   -DSOFTFLOAT_FAST_DIV64TO32
+
+==> DELETE = rm -f
+==> C_INCLUDES = -I. -I$(SOURCE_DIR)/$(SPECIALIZE_TYPE) -I$(SOURCE_DIR)/include
+==> COMPILE_C = cc -c $(SOFTFLOAT_OPTS) $(C_INCLUDES) -O2 -o $@
+==> MAKELIB = ar crs $@
+
+==> OBJ = .o
+==> LIB = .a
+
+==> OTHER_HEADERS =
+
+.PHONY: all
+all: softfloat$(LIB)
+
+OBJS_PRIMITIVES = \
+  s_compare96M$(OBJ) \
+  s_compare128M$(OBJ) \
+  s_shortShiftLeft64To96M$(OBJ) \
+  s_shortShiftLeftM$(OBJ) \
+  s_shiftLeftM$(OBJ) \
+  s_shortShiftRightM$(OBJ) \
+  s_shortShiftRightJam64$(OBJ) \
+  s_shortShiftRightJamM$(OBJ) \
+  s_shiftRightJam32$(OBJ) \
+  s_shiftRightJam64$(OBJ) \
+  s_shiftRightJamM$(OBJ) \
+  s_shiftRightM$(OBJ) \
+  s_countLeadingZeros8$(OBJ) \
+  s_countLeadingZeros16$(OBJ) \
+  s_countLeadingZeros32$(OBJ) \
+  s_countLeadingZeros64$(OBJ) \
+  s_addM$(OBJ) \
+  s_addCarryM$(OBJ) \
+  s_addComplCarryM$(OBJ) \
+  s_negXM$(OBJ) \
+  s_sub1XM$(OBJ) \
+  s_subM$(OBJ) \
+  s_mul64To128M$(OBJ) \
+  s_mul128MTo256M$(OBJ) \
+  s_approxRecip_1Ks$(OBJ) \
+  s_approxRecip32_1$(OBJ) \
+  s_approxRecipSqrt_1Ks$(OBJ) \
+  s_approxRecipSqrt32_1$(OBJ) \
+  s_remStepMBy32$(OBJ) \
+
+OBJS_SPECIALIZE = \
+  softfloat_raiseFlags$(OBJ) \
+  s_f16UIToCommonNaN$(OBJ) \
+  s_commonNaNToF16UI$(OBJ) \
+  s_propagateNaNF16UI$(OBJ) \
+  s_f32UIToCommonNaN$(OBJ) \
+  s_commonNaNToF32UI$(OBJ) \
+  s_propagateNaNF32UI$(OBJ) \
+  s_f64UIToCommonNaN$(OBJ) \
+  s_commonNaNToF64UI$(OBJ) \
+  s_propagateNaNF64UI$(OBJ) \
+  extF80M_isSignalingNaN$(OBJ) \
+  s_extF80MToCommonNaN$(OBJ) \
+  s_commonNaNToExtF80M$(OBJ) \
+  s_propagateNaNExtF80M$(OBJ) \
+  f128M_isSignalingNaN$(OBJ) \
+  s_f128MToCommonNaN$(OBJ) \
+  s_commonNaNToF128M$(OBJ) \
+  s_propagateNaNF128M$(OBJ) \
+
+OBJS_OTHERS = \
+  s_roundToUI32$(OBJ) \
+  s_roundMToUI64$(OBJ) \
+  s_roundToI32$(OBJ) \
+  s_roundMToI64$(OBJ) \
+  s_normSubnormalF16Sig$(OBJ) \
+  s_roundPackToF16$(OBJ) \
+  s_normRoundPackToF16$(OBJ) \
+  s_addMagsF16$(OBJ) \
+  s_subMagsF16$(OBJ) \
+  s_mulAddF16$(OBJ) \
+  s_normSubnormalF32Sig$(OBJ) \
+  s_roundPackToF32$(OBJ) \
+  s_normRoundPackToF32$(OBJ) \
+  s_addMagsF32$(OBJ) \
+  s_subMagsF32$(OBJ) \
+  s_mulAddF32$(OBJ) \
+  s_normSubnormalF64Sig$(OBJ) \
+  s_roundPackToF64$(OBJ) \
+  s_normRoundPackToF64$(OBJ) \
+  s_addMagsF64$(OBJ) \
+  s_subMagsF64$(OBJ) \
+  s_mulAddF64$(OBJ) \
+  s_tryPropagateNaNExtF80M$(OBJ) \
+  s_invalidExtF80M$(OBJ) \
+  s_normExtF80SigM$(OBJ) \
+  s_roundPackMToExtF80M$(OBJ) \
+  s_normRoundPackMToExtF80M$(OBJ) \
+  s_addExtF80M$(OBJ) \
+  s_compareNonnormExtF80M$(OBJ) \
+  s_isNaNF128M$(OBJ) \
+  s_tryPropagateNaNF128M$(OBJ) \
+  s_invalidF128M$(OBJ) \
+  s_shiftNormSigF128M$(OBJ) \
+  s_roundPackMToF128M$(OBJ) \
+  s_normRoundPackMToF128M$(OBJ) \
+  s_addF128M$(OBJ) \
+  s_mulAddF128M$(OBJ) \
+  softfloat_state$(OBJ) \
+  ui32_to_f16$(OBJ) \
+  ui32_to_f32$(OBJ) \
+  ui32_to_f64$(OBJ) \
+  ui32_to_extF80M$(OBJ) \
+  ui32_to_f128M$(OBJ) \
+  ui64_to_f16$(OBJ) \
+  ui64_to_f32$(OBJ) \
+  ui64_to_f64$(OBJ) \
+  ui64_to_extF80M$(OBJ) \
+  ui64_to_f128M$(OBJ) \
+  i32_to_f16$(OBJ) \
+  i32_to_f32$(OBJ) \
+  i32_to_f64$(OBJ) \
+  i32_to_extF80M$(OBJ) \
+  i32_to_f128M$(OBJ) \
+  i64_to_f16$(OBJ) \
+  i64_to_f32$(OBJ) \
+  i64_to_f64$(OBJ) \
+  i64_to_extF80M$(OBJ) \
+  i64_to_f128M$(OBJ) \
+  f16_to_ui32$(OBJ) \
+  f16_to_ui64$(OBJ) \
+  f16_to_i32$(OBJ) \
+  f16_to_i64$(OBJ) \
+  f16_to_ui32_r_minMag$(OBJ) \
+  f16_to_ui64_r_minMag$(OBJ) \
+  f16_to_i32_r_minMag$(OBJ) \
+  f16_to_i64_r_minMag$(OBJ) \
+  f16_to_f32$(OBJ) \
+  f16_to_f64$(OBJ) \
+  f16_to_extF80M$(OBJ) \
+  f16_to_f128M$(OBJ) \
+  f16_roundToInt$(OBJ) \
+  f16_add$(OBJ) \
+  f16_sub$(OBJ) \
+  f16_mul$(OBJ) \
+  f16_mulAdd$(OBJ) \
+  f16_div$(OBJ) \
+  f16_rem$(OBJ) \
+  f16_sqrt$(OBJ) \
+  f16_eq$(OBJ) \
+  f16_le$(OBJ) \
+  f16_lt$(OBJ) \
+  f16_eq_signaling$(OBJ) \
+  f16_le_quiet$(OBJ) \
+  f16_lt_quiet$(OBJ) \
+  f16_isSignalingNaN$(OBJ) \
+  f32_to_ui32$(OBJ) \
+  f32_to_ui64$(OBJ) \
+  f32_to_i32$(OBJ) \
+  f32_to_i64$(OBJ) \
+  f32_to_ui32_r_minMag$(OBJ) \
+  f32_to_ui64_r_minMag$(OBJ) \
+  f32_to_i32_r_minMag$(OBJ) \
+  f32_to_i64_r_minMag$(OBJ) \
+  f32_to_f16$(OBJ) \
+  f32_to_f64$(OBJ) \
+  f32_to_extF80M$(OBJ) \
+  f32_to_f128M$(OBJ) \
+  f32_roundToInt$(OBJ) \
+  f32_add$(OBJ) \
+  f32_sub$(OBJ) \
+  f32_mul$(OBJ) \
+  f32_mulAdd$(OBJ) \
+  f32_div$(OBJ) \
+  f32_rem$(OBJ) \
+  f32_sqrt$(OBJ) \
+  f32_eq$(OBJ) \
+  f32_le$(OBJ) \
+  f32_lt$(OBJ) \
+  f32_eq_signaling$(OBJ) \
+  f32_le_quiet$(OBJ) \
+  f32_lt_quiet$(OBJ) \
+  f32_isSignalingNaN$(OBJ) \
+  f64_to_ui32$(OBJ) \
+  f64_to_ui64$(OBJ) \
+  f64_to_i32$(OBJ) \
+  f64_to_i64$(OBJ) \
+  f64_to_ui32_r_minMag$(OBJ) \
+  f64_to_ui64_r_minMag$(OBJ) \
+  f64_to_i32_r_minMag$(OBJ) \
+  f64_to_i64_r_minMag$(OBJ) \
+  f64_to_f16$(OBJ) \
+  f64_to_f32$(OBJ) \
+  f64_to_extF80M$(OBJ) \
+  f64_to_f128M$(OBJ) \
+  f64_roundToInt$(OBJ) \
+  f64_add$(OBJ) \
+  f64_sub$(OBJ) \
+  f64_mul$(OBJ) \
+  f64_mulAdd$(OBJ) \
+  f64_div$(OBJ) \
+  f64_rem$(OBJ) \
+  f64_sqrt$(OBJ) \
+  f64_eq$(OBJ) \
+  f64_le$(OBJ) \
+  f64_lt$(OBJ) \
+  f64_eq_signaling$(OBJ) \
+  f64_le_quiet$(OBJ) \
+  f64_lt_quiet$(OBJ) \
+  f64_isSignalingNaN$(OBJ) \
+  extF80M_to_ui32$(OBJ) \
+  extF80M_to_ui64$(OBJ) \
+  extF80M_to_i32$(OBJ) \
+  extF80M_to_i64$(OBJ) \
+  extF80M_to_ui32_r_minMag$(OBJ) \
+  extF80M_to_ui64_r_minMag$(OBJ) \
+  extF80M_to_i32_r_minMag$(OBJ) \
+  extF80M_to_i64_r_minMag$(OBJ) \
+  extF80M_to_f16$(OBJ) \
+  extF80M_to_f32$(OBJ) \
+  extF80M_to_f64$(OBJ) \
+  extF80M_to_f128M$(OBJ) \
+  extF80M_roundToInt$(OBJ) \
+  extF80M_add$(OBJ) \
+  extF80M_sub$(OBJ) \
+  extF80M_mul$(OBJ) \
+  extF80M_div$(OBJ) \
+  extF80M_rem$(OBJ) \
+  extF80M_sqrt$(OBJ) \
+  extF80M_eq$(OBJ) \
+  extF80M_le$(OBJ) \
+  extF80M_lt$(OBJ) \
+  extF80M_eq_signaling$(OBJ) \
+  extF80M_le_quiet$(OBJ) \
+  extF80M_lt_quiet$(OBJ) \
+  f128M_to_ui32$(OBJ) \
+  f128M_to_ui64$(OBJ) \
+  f128M_to_i32$(OBJ) \
+  f128M_to_i64$(OBJ) \
+  f128M_to_ui32_r_minMag$(OBJ) \
+  f128M_to_ui64_r_minMag$(OBJ) \
+  f128M_to_i32_r_minMag$(OBJ) \
+  f128M_to_i64_r_minMag$(OBJ) \
+  f128M_to_f16$(OBJ) \
+  f128M_to_f32$(OBJ) \
+  f128M_to_f64$(OBJ) \
+  f128M_to_extF80M$(OBJ) \
+  f128M_roundToInt$(OBJ) \
+  f128M_add$(OBJ) \
+  f128M_sub$(OBJ) \
+  f128M_mul$(OBJ) \
+  f128M_mulAdd$(OBJ) \
+  f128M_div$(OBJ) \
+  f128M_rem$(OBJ) \
+  f128M_sqrt$(OBJ) \
+  f128M_eq$(OBJ) \
+  f128M_le$(OBJ) \
+  f128M_lt$(OBJ) \
+  f128M_eq_signaling$(OBJ) \
+  f128M_le_quiet$(OBJ) \
+  f128M_lt_quiet$(OBJ) \
+
+OBJS_ALL = $(OBJS_PRIMITIVES) $(OBJS_SPECIALIZE) $(OBJS_OTHERS)
+
+$(OBJS_ALL): \
+  $(OTHER_HEADERS) platform.h $(SOURCE_DIR)/include/primitiveTypes.h \
+  $(SOURCE_DIR)/include/primitives.h
+$(OBJS_SPECIALIZE) $(OBJS_OTHERS): \
+  $(SOURCE_DIR)/include/softfloat_types.h $(SOURCE_DIR)/include/internals.h \
+  $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/specialize.h \
+  $(SOURCE_DIR)/include/softfloat.h
+
+$(OBJS_PRIMITIVES) $(OBJS_OTHERS): %$(OBJ): $(SOURCE_DIR)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$*.c
+
+$(OBJS_SPECIALIZE): %$(OBJ): $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/%.c
+	$(COMPILE_C) $(SOURCE_DIR)/$(SPECIALIZE_TYPE)/$*.c
+
+softfloat$(LIB): $(OBJS_ALL)
+	$(DELETE) $@
+	$(MAKELIB) $^
+
+.PHONY: clean
+clean:
+	$(DELETE) $(OBJS_ALL) softfloat$(LIB)
+
diff --git a/softfloat/build/template-not-FAST_INT64/platform.h b/softfloat/build/template-not-FAST_INT64/platform.h
index b59e6c5..2094658 100644
--- a/softfloat/build/template-not-FAST_INT64/platform.h
+++ b/softfloat/build/template-not-FAST_INT64/platform.h
@@ -1,49 +1,50 @@
-
-/*============================================================================
-
-This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-// Edit lines marked with `==>'.  See "SoftFloat-source.html".
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-== > #define LITTLEENDIAN 1
-
-    /*----------------------------------------------------------------------------
-     *----------------------------------------------------------------------------*/
-    == > #define INLINE inline
-
-    /*----------------------------------------------------------------------------
-     *----------------------------------------------------------------------------*/
-    == > #define THREAD_LOCAL _Thread_local
+
+/*============================================================================
+
+This C header template is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+// Edit lines marked with `==>'.  See "SoftFloat-source.html".
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define LITTLEENDIAN 1
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define INLINE inline
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+==> #define THREAD_LOCAL _Thread_local
+
diff --git a/softfloat/doc/SoftFloat-history.html b/softfloat/doc/SoftFloat-history.html
index daa48ca..d81c6bc 100644
--- a/softfloat/doc/SoftFloat-history.html
+++ b/softfloat/doc/SoftFloat-history.html
@@ -1,258 +1,258 @@
-
-<HTML>
-
-<HEAD>
-<TITLE>Berkeley SoftFloat History</TITLE>
-</HEAD>
-
-<BODY>
-
-<H1>History of Berkeley SoftFloat, to Release 3e</H1>
-
-<P>
-John R. Hauser<BR>
-2018 January 20<BR>
-</P>
-
-
-<H3>Release 3e (2018 January)</H3>
-
-<UL>
-
-<LI>
-Changed the default numeric code for optional rounding mode <CODE>odd</CODE>
-(round to odd, also known as <EM>jamming</EM>) from 5 to 6.
-
-<LI>
-Modified the behavior of rounding mode <CODE>odd</CODE> when rounding to an
-integer value (either conversion to an integer format or a
-&lsquo;<CODE>roundToInt</CODE>&rsquo; function).
-Previously, for those cases only, rounding mode <CODE>odd</CODE> acted the same
-as rounding to minimum magnitude.
-Now all operations are rounded consistently.
-
-<LI>
-Fixed some errors in the specialization code modeling Intel x86 floating-point,
-specifically the integers returned on invalid operations and the propagation of
-NaN payloads in a few rare cases.
-
-<LI>
-Added specialization code modeling ARM floating-point, conforming to VFPv2 or
-later.
-
-<LI>
-Added an example target for ARM processors.
-
-<LI>
-Fixed a minor bug whereby function <CODE>f16_to_ui64</CODE> might return a
-different integer than expected in the case that the floating-point operand is
-negative.
-
-<LI>
-Added example target-specific optimization for GCC, employing GCC instrinsics
-and support for <NOBR>128-bit</NOBR> integer arithmetic.
-
-<LI>
-Made other minor improvements.
-
-</UL>
-
-
-<H3>Release 3d (2017 August)</H3>
-
-<UL>
-
-<LI>
-Fixed bugs in the square root functions for <NOBR>64-bit</NOBR>
-double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
-<NOBR>128-bit</NOBR> quadruple-precision.
-For <NOBR>64-bit</NOBR> double-precision (<CODE>f64_sqrt</CODE>), the result
-could sometimes be off by <NOBR>1 unit</NOBR> in the last place
-(<NOBR>1 ulp</NOBR>) from what it should be.
-For the larger formats, the square root could be wrong in a large portion of
-the less-significant bits.
-(A bug in <CODE>f128_sqrt</CODE> was first reported by Alexei Sibidanov.)
-
-</UL>
-
-
-<H3>Release 3c (2017 February)</H3>
-
-<UL>
-
-<LI>
-Added optional rounding mode <CODE>odd</CODE> (round to odd, also known as
-<EM>jamming</EM>).
-
-<LI>
-Corrected the documentation concerning non-canonical representations in
-<NOBR>80-bit</NOBR> double-extended-precision.
-
-</UL>
-
-
-<H3>Release 3b (2016 July)</H3>
-
-<UL>
-
-<LI>
-Implemented the common <NOBR>16-bit</NOBR> &ldquo;half-precision&rdquo;
-floating-point format (<CODE>float16_t</CODE>).
-
-<LI>
-Made the integer values returned on invalid conversions to integer formats
-be determined by the port-specific specialization instead of being the same for
-all ports.
-
-<LI>
-Added preprocessor macro <CODE>THREAD_LOCAL</CODE> to allow the floating-point
-state (modes and exception flags) to be made per-thread.
-
-<LI>
-Modified the provided Makefiles to allow some options to be overridden from the
-<CODE>make</CODE> command.
-
-<LI>
-Made other minor improvements.
-
-</UL>
-
-
-<H3>Release 3a (2015 October)</H3>
-
-<UL>
-
-<LI>
-Replaced the license text supplied by the University of California, Berkeley.
-
-</UL>
-
-
-<H3>Release 3 (2015 February)</H3>
-
-<UL>
-
-<LI>
-Complete rewrite, funded by the University of California, Berkeley, and
-consequently having a different use license than earlier releases.
-Major changes included renaming most types and functions, upgrading some
-algorithms, restructuring the source files, and making SoftFloat into a true
-library.
-
-<LI>
-Added functions to convert between floating-point and unsigned integers, both
-<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> (<CODE>uint32_t</CODE> and
-<CODE>uint64_t</CODE>).
-
-<LI>
-Added functions for fused multiply-add, for all supported floating-point
-formats except <NOBR>80-bit</NOBR> double-extended-precision.
-
-<LI>
-Added support for a fifth rounding mode, <CODE>near_maxMag</CODE> (round to
-nearest, with ties to maximum magnitude, away from zero).
-
-<LI>
-Dropped the <CODE>timesoftfloat</CODE> program (now part of the Berkeley
-TestFloat package).
-
-</UL>
-
-
-<H3>Release 2c (2015 January)</H3>
-
-<UL>
-
-<LI>
-Fixed mistakes affecting some <NOBR>64-bit</NOBR> processors.
-
-<LI>
-Further improved the documentation and the wording for the legal restrictions
-on using SoftFloat releases <NOBR>through 2c</NOBR> (not applicable to
-<NOBR>Release 3</NOBR> or later).
-
-</UL>
-
-
-<H3>Release 2b (2002 May)</H3>
-
-<UL>
-
-<LI>
-Made minor updates to the documentation, including improved wording for the
-legal restrictions on using SoftFloat.
-
-</UL>
-
-
-<H3>Release 2a (1998 December)</H3>
-
-<UL>
-
-<LI>
-Added functions to convert between <NOBR>64-bit</NOBR> integers
-(<CODE>int64</CODE>) and all supported floating-point formats.
-
-<LI>
-Fixed a bug in all <NOBR>64-bit</NOBR>-version square root functions except
-<CODE>float32_sqrt</CODE> that caused the result sometimes to be off by
-<NOBR>1 unit</NOBR> in the last place (<NOBR>1 ulp</NOBR>) from what it should
-be.
-(Bug discovered by Paul Donahue.)
-
-<LI>
-Improved the Makefiles.
-</UL>
-
-
-<H3>Release 2 (1997 June)</H3>
-
-<UL>
-
-<LI>
-Created the <NOBR>64-bit</NOBR> (<CODE>bits64</CODE>) version, adding the
-<CODE>floatx80</CODE> and <CODE>float128</CODE> formats.
-
-<LI>
-Changed the source directory structure, splitting the sources into a
-<CODE>bits32</CODE> and a <CODE>bits64</CODE> version.
-Renamed <CODE>environment.h</CODE> to <CODE>milieu.h</CODE> to avoid confusion
-with environment variables.
-
-<LI>
-Fixed a small error that caused <CODE>float64_round_to_int</CODE> often to
-round the wrong way in nearest/even mode when the operand was between
-2<SUP>20</SUP> and 2<SUP>21</SUP> and halfway between two integers.
-
-</UL>
-
-
-<H3>Release 1a (1996 July)</H3>
-
-<UL>
-
-<LI>
-Corrected a mistake that caused borderline underflow cases not to raise the
-underflow flag when they should have.
-(Problem reported by Doug Priest.)
-
-<LI>
-Added the <CODE>float_detect_tininess</CODE> variable to control whether
-tininess is detected before or after rounding.
-
-</UL>
-
-
-<H3>Release 1 (1996 July)</H3>
-
-<UL>
-
-<LI>
-Original release, based on work done for the International Computer Science
-Institute (ICSI) in Berkeley, California.
-
-</UL>
-
-
-</BODY>
-
+
+<HTML>
+
+<HEAD>
+<TITLE>Berkeley SoftFloat History</TITLE>
+</HEAD>
+
+<BODY>
+
+<H1>History of Berkeley SoftFloat, to Release 3e</H1>
+
+<P>
+John R. Hauser<BR>
+2018 January 20<BR>
+</P>
+
+
+<H3>Release 3e (2018 January)</H3>
+
+<UL>
+
+<LI>
+Changed the default numeric code for optional rounding mode <CODE>odd</CODE>
+(round to odd, also known as <EM>jamming</EM>) from 5 to 6.
+
+<LI>
+Modified the behavior of rounding mode <CODE>odd</CODE> when rounding to an
+integer value (either conversion to an integer format or a
+&lsquo;<CODE>roundToInt</CODE>&rsquo; function).
+Previously, for those cases only, rounding mode <CODE>odd</CODE> acted the same
+as rounding to minimum magnitude.
+Now all operations are rounded consistently.
+
+<LI>
+Fixed some errors in the specialization code modeling Intel x86 floating-point,
+specifically the integers returned on invalid operations and the propagation of
+NaN payloads in a few rare cases.
+
+<LI>
+Added specialization code modeling ARM floating-point, conforming to VFPv2 or
+later.
+
+<LI>
+Added an example target for ARM processors.
+
+<LI>
+Fixed a minor bug whereby function <CODE>f16_to_ui64</CODE> might return a
+different integer than expected in the case that the floating-point operand is
+negative.
+
+<LI>
+Added example target-specific optimization for GCC, employing GCC instrinsics
+and support for <NOBR>128-bit</NOBR> integer arithmetic.
+
+<LI>
+Made other minor improvements.
+
+</UL>
+
+
+<H3>Release 3d (2017 August)</H3>
+
+<UL>
+
+<LI>
+Fixed bugs in the square root functions for <NOBR>64-bit</NOBR>
+double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
+<NOBR>128-bit</NOBR> quadruple-precision.
+For <NOBR>64-bit</NOBR> double-precision (<CODE>f64_sqrt</CODE>), the result
+could sometimes be off by <NOBR>1 unit</NOBR> in the last place
+(<NOBR>1 ulp</NOBR>) from what it should be.
+For the larger formats, the square root could be wrong in a large portion of
+the less-significant bits.
+(A bug in <CODE>f128_sqrt</CODE> was first reported by Alexei Sibidanov.)
+
+</UL>
+
+
+<H3>Release 3c (2017 February)</H3>
+
+<UL>
+
+<LI>
+Added optional rounding mode <CODE>odd</CODE> (round to odd, also known as
+<EM>jamming</EM>).
+
+<LI>
+Corrected the documentation concerning non-canonical representations in
+<NOBR>80-bit</NOBR> double-extended-precision.
+
+</UL>
+
+
+<H3>Release 3b (2016 July)</H3>
+
+<UL>
+
+<LI>
+Implemented the common <NOBR>16-bit</NOBR> &ldquo;half-precision&rdquo;
+floating-point format (<CODE>float16_t</CODE>).
+
+<LI>
+Made the integer values returned on invalid conversions to integer formats
+be determined by the port-specific specialization instead of being the same for
+all ports.
+
+<LI>
+Added preprocessor macro <CODE>THREAD_LOCAL</CODE> to allow the floating-point
+state (modes and exception flags) to be made per-thread.
+
+<LI>
+Modified the provided Makefiles to allow some options to be overridden from the
+<CODE>make</CODE> command.
+
+<LI>
+Made other minor improvements.
+
+</UL>
+
+
+<H3>Release 3a (2015 October)</H3>
+
+<UL>
+
+<LI>
+Replaced the license text supplied by the University of California, Berkeley.
+
+</UL>
+
+
+<H3>Release 3 (2015 February)</H3>
+
+<UL>
+
+<LI>
+Complete rewrite, funded by the University of California, Berkeley, and
+consequently having a different use license than earlier releases.
+Major changes included renaming most types and functions, upgrading some
+algorithms, restructuring the source files, and making SoftFloat into a true
+library.
+
+<LI>
+Added functions to convert between floating-point and unsigned integers, both
+<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> (<CODE>uint32_t</CODE> and
+<CODE>uint64_t</CODE>).
+
+<LI>
+Added functions for fused multiply-add, for all supported floating-point
+formats except <NOBR>80-bit</NOBR> double-extended-precision.
+
+<LI>
+Added support for a fifth rounding mode, <CODE>near_maxMag</CODE> (round to
+nearest, with ties to maximum magnitude, away from zero).
+
+<LI>
+Dropped the <CODE>timesoftfloat</CODE> program (now part of the Berkeley
+TestFloat package).
+
+</UL>
+
+
+<H3>Release 2c (2015 January)</H3>
+
+<UL>
+
+<LI>
+Fixed mistakes affecting some <NOBR>64-bit</NOBR> processors.
+
+<LI>
+Further improved the documentation and the wording for the legal restrictions
+on using SoftFloat releases <NOBR>through 2c</NOBR> (not applicable to
+<NOBR>Release 3</NOBR> or later).
+
+</UL>
+
+
+<H3>Release 2b (2002 May)</H3>
+
+<UL>
+
+<LI>
+Made minor updates to the documentation, including improved wording for the
+legal restrictions on using SoftFloat.
+
+</UL>
+
+
+<H3>Release 2a (1998 December)</H3>
+
+<UL>
+
+<LI>
+Added functions to convert between <NOBR>64-bit</NOBR> integers
+(<CODE>int64</CODE>) and all supported floating-point formats.
+
+<LI>
+Fixed a bug in all <NOBR>64-bit</NOBR>-version square root functions except
+<CODE>float32_sqrt</CODE> that caused the result sometimes to be off by
+<NOBR>1 unit</NOBR> in the last place (<NOBR>1 ulp</NOBR>) from what it should
+be.
+(Bug discovered by Paul Donahue.)
+
+<LI>
+Improved the Makefiles.
+</UL>
+
+
+<H3>Release 2 (1997 June)</H3>
+
+<UL>
+
+<LI>
+Created the <NOBR>64-bit</NOBR> (<CODE>bits64</CODE>) version, adding the
+<CODE>floatx80</CODE> and <CODE>float128</CODE> formats.
+
+<LI>
+Changed the source directory structure, splitting the sources into a
+<CODE>bits32</CODE> and a <CODE>bits64</CODE> version.
+Renamed <CODE>environment.h</CODE> to <CODE>milieu.h</CODE> to avoid confusion
+with environment variables.
+
+<LI>
+Fixed a small error that caused <CODE>float64_round_to_int</CODE> often to
+round the wrong way in nearest/even mode when the operand was between
+2<SUP>20</SUP> and 2<SUP>21</SUP> and halfway between two integers.
+
+</UL>
+
+
+<H3>Release 1a (1996 July)</H3>
+
+<UL>
+
+<LI>
+Corrected a mistake that caused borderline underflow cases not to raise the
+underflow flag when they should have.
+(Problem reported by Doug Priest.)
+
+<LI>
+Added the <CODE>float_detect_tininess</CODE> variable to control whether
+tininess is detected before or after rounding.
+
+</UL>
+
+
+<H3>Release 1 (1996 July)</H3>
+
+<UL>
+
+<LI>
+Original release, based on work done for the International Computer Science
+Institute (ICSI) in Berkeley, California.
+
+</UL>
+
+
+</BODY>
+
diff --git a/softfloat/doc/SoftFloat-source.html b/softfloat/doc/SoftFloat-source.html
index d4b85f7..4ff9d4c 100644
--- a/softfloat/doc/SoftFloat-source.html
+++ b/softfloat/doc/SoftFloat-source.html
@@ -1,686 +1,686 @@
-
-<HTML>
-
-<HEAD>
-<TITLE>Berkeley SoftFloat Source Documentation</TITLE>
-</HEAD>
-
-<BODY>
-
-<H1>Berkeley SoftFloat Release 3e: Source Documentation</H1>
-
-<P>
-John R. Hauser<BR>
-2018 January 20<BR>
-</P>
-
-
-<H2>Contents</H2>
-
-<BLOCKQUOTE>
-<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
-<COL WIDTH=25>
-<COL WIDTH=*>
-<TR><TD COLSPAN=2>1. Introduction</TD></TR>
-<TR><TD COLSPAN=2>2. Limitations</TD></TR>
-<TR><TD COLSPAN=2>3. Acknowledgments and License</TD></TR>
-<TR><TD COLSPAN=2>4. SoftFloat Package Directory Structure</TD></TR>
-<TR><TD COLSPAN=2>5. Issues for Porting SoftFloat to a New Target</TD></TR>
-<TR>
-  <TD></TD>
-  <TD>5.1. Standard Headers <CODE>&lt;stdbool.h&gt;</CODE> and
-    <CODE>&lt;stdint.h&gt;</CODE></TD>
-</TR>
-<TR><TD></TD><TD>5.2. Specializing Floating-Point Behavior</TD></TR>
-<TR><TD></TD><TD>5.3. Macros for Build Options</TD></TR>
-<TR><TD></TD><TD>5.4. Adapting a Template Target Directory</TD></TR>
-<TR>
-  <TD></TD><TD>5.5. Target-Specific Optimization of Primitive Functions</TD>
-</TR>
-<TR><TD COLSPAN=2>6. Testing SoftFloat</TD></TR>
-<TR>
-  <TD COLSPAN=2>7. Providing SoftFloat as a Common Library for Applications</TD>
-</TR>
-<TR><TD COLSPAN=2>8. Contact Information</TD></TR>
-</TABLE>
-</BLOCKQUOTE>
-
-
-<H2>1. Introduction</H2>
-
-<P>
-This document gives information needed for compiling and/or porting Berkeley
-SoftFloat, a library of C functions implementing binary floating-point
-conforming to the IEEE Standard for Floating-Point Arithmetic.
-For basic documentation about SoftFloat refer to
-<A HREF="SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A>.
-</P>
-
-<P>
-The source code for SoftFloat is intended to be relatively machine-independent
-and should be compilable with any ISO-Standard C compiler that also supports
-<NOBR>64-bit</NOBR> integers.
-SoftFloat has been successfully compiled with the GNU C Compiler
-(<CODE>gcc</CODE>) for several platforms.
-</P>
-
-<P>
-<NOBR>Release 3</NOBR> of SoftFloat was a complete rewrite relative to
-<NOBR>Release 2</NOBR> or earlier.
-Changes to the interface of SoftFloat functions are documented in
-<A HREF="SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A>.
-The current version of SoftFloat is <NOBR>Release 3e</NOBR>.
-</P>
-
-
-<H2>2. Limitations</H2>
-
-<P>
-SoftFloat assumes the computer has an addressable byte size of either 8 or
-<NOBR>16 bits</NOBR>.
-(Nearly all computers in use today have <NOBR>8-bit</NOBR> bytes.)
-</P>
-
-<P>
-SoftFloat is written in C and is designed to work with other C code.
-The C compiler used must conform at a minimum to the 1989 ANSI standard for the
-C language (same as the 1990 ISO standard) and must in addition support basic
-arithmetic on <NOBR>64-bit</NOBR> integers.
-Earlier releases of SoftFloat included implementations of <NOBR>32-bit</NOBR>
-single-precision and <NOBR>64-bit</NOBR> double-precision floating-point that
-did not require <NOBR>64-bit</NOBR> integers, but this option is not supported
-starting with <NOBR>Release 3</NOBR>.
-Since 1999, ISO standards for C have mandated compiler support for
-<NOBR>64-bit</NOBR> integers.
-A compiler conforming to the 1999 C Standard or later is recommended but not
-strictly required.
-</P>
-
-<P>
-<NOBR>C Standard</NOBR> header files <CODE>&lt;stdbool.h&gt;</CODE> and
-<CODE>&lt;stdint.h&gt;</CODE> are required for defining standard Boolean and
-integer types.
-If these headers are not supplied with the C compiler, minimal substitutes must
-be provided.
-SoftFloat&rsquo;s dependence on these headers is detailed later in
-<NOBR>section 5.1</NOBR>, <I>Standard Headers <CODE>&lt;stdbool.h&gt;</CODE>
-and <CODE>&lt;stdint.h&gt;</CODE></I>.
-</P>
-
-
-<H2>3. Acknowledgments and License</H2>
-
-<P>
-The SoftFloat package was written by me, <NOBR>John R.</NOBR> Hauser.
-<NOBR>Release 3</NOBR> of SoftFloat was a completely new implementation
-supplanting earlier releases.
-The project to create <NOBR>Release 3</NOBR> (now <NOBR>through 3e</NOBR>) was
-done in the employ of the University of California, Berkeley, within the
-Department of Electrical Engineering and Computer Sciences, first for the
-Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
-The work was officially overseen by Prof. Krste Asanovic, with funding provided
-by these sources:
-<BLOCKQUOTE>
-<TABLE>
-<COL>
-<COL WIDTH=10>
-<COL>
-<TR>
-<TD VALIGN=TOP><NOBR>Par Lab:</NOBR></TD>
-<TD></TD>
-<TD>
-Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
-(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
-NVIDIA, Oracle, and Samsung.
-</TD>
-</TR>
-<TR>
-<TD VALIGN=TOP><NOBR>ASPIRE Lab:</NOBR></TD>
-<TD></TD>
-<TD>
-DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
-ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
-Oracle, and Samsung.
-</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-The following applies to the whole of SoftFloat <NOBR>Release 3e</NOBR> as well
-as to each source file individually.
-</P>
-
-<P>
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.
-All rights reserved.
-</P>
-
-<P>
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-<OL>
-
-<LI>
-<P>
-Redistributions of source code must retain the above copyright notice, this
-list of conditions, and the following disclaimer.
-</P>
-
-<LI>
-<P>
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions, and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-</P>
-
-<LI>
-<P>
-Neither the name of the University nor the names of its contributors may be
-used to endorse or promote products derived from this software without specific
-prior written permission.
-</P>
-
-</OL>
-</P>
-
-<P>
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS &ldquo;AS IS&rdquo;,
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.
-IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-</P>
-
-
-<H2>4. SoftFloat Package Directory Structure</H2>
-
-<P>
-Because SoftFloat is targeted to multiple platforms, its source code is
-slightly scattered between target-specific and target-independent directories
-and files.
-The supplied directory structure is as follows:
-<BLOCKQUOTE>
-<PRE>
-doc
-source
-    include
-    8086
-    8086-SSE
-    ARM-VFPv2
-    ARM-VFPv2-defaultNaN
-build
-    template-FAST_INT64
-    template-not-FAST_INT64
-    Linux-386-GCC
-    Linux-386-SSE2-GCC
-    Linux-x86_64-GCC
-    Linux-ARM-VFPv2-GCC
-    Win32-MinGW
-    Win32-SSE2-MinGW
-    Win64-MinGW-w64
-</PRE>
-</BLOCKQUOTE>
-The majority of the SoftFloat sources are provided in the <CODE>source</CODE>
-directory.
-The <CODE>include</CODE> subdirectory contains several header files
-(unsurprisingly), while the other subdirectories of <CODE>source</CODE> contain
-source files that specialize the floating-point behavior to match particular
-processor families:
-<BLOCKQUOTE>
-<DL>
-<DT><CODE>8086</CODE></DT>
-<DD>
-Intel&rsquo;s older, 8087-derived floating-point, extended to all supported
-floating-point types
-</DD>
-<DT><CODE>8086-SSE</CODE></DT>
-<DD>
-Intel&rsquo;s x86 processors with Streaming SIMD Extensions (SSE) and later
-compatible extensions, having 8087 behavior for <NOBR>80-bit</NOBR>
-double-extended-precision (<CODE>extFloat80_t</CODE>) and SSE behavior for
-other floating-point types
-</DD>
-<DT><CODE>ARM-VFPv2</CODE></DT>
-<DD>
-ARM&rsquo;s VFPv2 or later floating-point, with NaN payload propagation
-</DD>
-<DT><CODE>ARM-VFPv2-defaultNaN</CODE></DT>
-<DD>
-ARM&rsquo;s VFPv2 or later floating-point, with the &ldquo;default NaN&rdquo;
-option
-</DD>
-</DL>
-</BLOCKQUOTE>
-If other specializations are attempted, these would be expected to be other
-subdirectories of <CODE>source</CODE> alongside the ones listed above.
-Specialization is covered later, in <NOBR>section 5.2</NOBR>, <I>Specializing
-Floating-Point Behavior</I>.
-</P>
-
-<P>
-The <CODE>build</CODE> directory is intended to contain a subdirectory for each
-target platform for which a build of the SoftFloat library may be created.
-For each build target, the target&rsquo;s subdirectory is where all derived
-object files and the completed SoftFloat library (typically
-<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) are created.
-The two <CODE>template</CODE> subdirectories are not actual build targets but
-contain sample files for creating new target directories.
-(The meaning of <CODE>FAST_INT64</CODE> will be explained later.)
-</P>
-
-<P>
-Ignoring the <CODE>template</CODE> directories, the supplied target directories
-are intended to follow a naming system of
-<NOBR><CODE>&lt;<I>execution-environment</I>&gt;-&lt;<I>compiler</I>&gt;</CODE></NOBR>.
-For the example targets,
-<NOBR><CODE>&lt;<I>execution-environment</I>&gt;</CODE></NOBR> is
-<NOBR><CODE>Linux-386</CODE></NOBR>, <NOBR><CODE>Linux-386-SSE2</CODE></NOBR>,
-<NOBR><CODE>Linux-x86_64</CODE></NOBR>,
-<NOBR><CODE>Linux-ARM-VFPv2</CODE></NOBR>, <CODE>Win32</CODE>,
-<NOBR><CODE>Win32-SSE2</CODE></NOBR>, or <CODE>Win64</CODE>, and
-<NOBR><CODE>&lt;<I>compiler</I>&gt;</CODE></NOBR> is <CODE>GCC</CODE>,
-<CODE>MinGW</CODE>, or <NOBR><CODE>MinGW-w64</CODE></NOBR>.
-</P>
-
-<P>
-All of the supplied target directories are merely examples that may or may not
-be correct for compiling on any particular system.
-Despite requests, there are currently no plans to include and maintain in the
-SoftFloat package the build files needed for a great many users&rsquo;
-compilation environments, which can span a huge range of operating systems,
-compilers, and other tools.
-</P>
-
-<P>
-As supplied, each target directory contains two files:
-<BLOCKQUOTE>
-<PRE>
-Makefile
-platform.h
-</PRE>
-</BLOCKQUOTE>
-The provided <CODE>Makefile</CODE> is written for GNU <CODE>make</CODE>.
-A build of SoftFloat for the specific target is begun by executing the
-<CODE>make</CODE> command with the target directory as the current directory.
-A completely different build tool can be used if an appropriate
-<CODE>Makefile</CODE> equivalent is created.
-</P>
-
-<P>
-The <CODE>platform.h</CODE> header file exists to provide a location for
-additional C declarations specific to the build target.
-Every C source file of SoftFloat contains a <CODE>#include</CODE> for
-<CODE>platform.h</CODE>.
-In many cases, the contents of <CODE>platform.h</CODE> can be as simple as one
-or two lines of code.
-At the other extreme, to get maximal performance from SoftFloat, it may be
-desirable to include in header <CODE>platform.h</CODE> (directly or via
-<CODE>#include</CODE>) declarations for numerous target-specific optimizations.
-Such possibilities are discussed in the next section, <I>Issues for Porting
-SoftFloat to a New Target</I>.
-If the target&rsquo;s compiler or library has bugs or other shortcomings,
-workarounds for these issues may also be possible with target-specific
-declarations in <CODE>platform.h</CODE>, avoiding the need to modify the main
-SoftFloat sources.
-</P>
-
-
-<H2>5. Issues for Porting SoftFloat to a New Target</H2>
-
-<H3>5.1. Standard Headers <CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE></H3>
-
-<P>
-The SoftFloat sources make use of standard headers
-<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE>, which have
-been part of the ISO C Standard Library since 1999.
-With any recent compiler, these standard headers are likely to be supported,
-even if the compiler does not claim complete conformance to the latest ISO C
-Standard.
-For older or nonstandard compilers, substitutes for
-<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE> may need to be
-created.
-SoftFloat depends on these names from <CODE>&lt;stdbool.h&gt;</CODE>:
-<BLOCKQUOTE>
-<PRE>
-bool
-true
-false
-</PRE>
-</BLOCKQUOTE>
-and on these names from <CODE>&lt;stdint.h&gt;</CODE>:
-<BLOCKQUOTE>
-<PRE>
-uint16_t
-uint32_t
-uint64_t
-int32_t
-int64_t
-UINT64_C
-INT64_C
-uint_least8_t
-uint_fast8_t
-uint_fast16_t
-uint_fast32_t
-uint_fast64_t
-int_fast8_t
-int_fast16_t
-int_fast32_t
-int_fast64_t
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-
-<H3>5.2. Specializing Floating-Point Behavior</H3>
-
-<P>
-The IEEE Floating-Point Standard allows for some flexibility in a conforming
-implementation, particularly concerning NaNs.
-The SoftFloat <CODE>source</CODE> directory is supplied with some
-<I>specialization</I> subdirectories containing possible definitions for this
-implementation-specific behavior.
-For example, the <CODE>8086</CODE> and <NOBR><CODE>8086-SSE</CODE></NOBR>
-subdirectories have source files that specialize SoftFloat&rsquo;s behavior to
-match that of Intel&rsquo;s x86 line of processors.
-The files in a specialization subdirectory must determine:
-<UL>
-<LI>
-whether tininess for underflow is detected before or after rounding by default;
-<LI>
-how signaling NaNs are distinguished from quiet NaNs;
-<LI>
-what (if anything) special happens when exceptions are raised;
-<LI>
-the default generated quiet NaNs;
-<LI>
-how NaNs are propagated from function inputs to output; and
-<LI>
-the integer results returned when conversions to integer type raise the
-<I>invalid</I> exception.
-</UL>
-</P>
-
-<P>
-As provided, the build process for a target expects to involve exactly
-<EM>one</EM> specialization directory that defines <EM>all</EM> of these
-implementation-specific details for the target.
-A specialization directory such as <CODE>8086</CODE> is expected to contain a
-header file called <CODE>specialize.h</CODE>, together with whatever other
-source files are needed to complete the specialization.
-</P>
-
-<P>
-A new build target may use an existing specialization, such as the ones
-provided by the <CODE>8086</CODE> and <NOBR><CODE>8086-SSE</CODE></NOBR>
-subdirectories.
-If a build target needs a new specialization, different from any existing ones,
-it is recommended that a new specialization directory be created for this
-purpose.
-The <CODE>specialize.h</CODE> header file from any of the provided
-specialization subdirectories can be used as a model for what definitions are
-needed.
-</P>
-
-
-<H3>5.3. Macros for Build Options</H3>
-
-<P>
-The SoftFloat source files adapt the floating-point implementation according to
-several C preprocessor macros:
-<BLOCKQUOTE>
-<DL>
-<DT><CODE>LITTLEENDIAN</CODE>
-<DD>
-Must be defined for little-endian machines; must not be defined for big-endian
-machines.
-<DT><CODE>INLINE</CODE>
-<DD>
-Specifies the sequence of tokens used to indicate that a C function should be
-inlined.
-If macro <CODE>INLINE_LEVEL</CODE> is defined with a value of 1 or higher, this
-macro must be defined; otherwise, this macro is ignored and need not be
-defined.
-For compilers that conform to the C Standard&rsquo;s rules for inline
-functions, this macro can be defined as the single keyword <CODE>inline</CODE>.
-For other compilers that follow a convention pre-dating the standardization of
-<CODE>inline</CODE>, this macro may need to be defined to <CODE>extern</CODE>
-<CODE>inline</CODE>.
-<DT><CODE>THREAD_LOCAL</CODE>
-<DD>
-Can be defined to a sequence of tokens that, when appearing at the start of a
-variable declaration, indicates to the C compiler that the variable is
-<I>per-thread</I>, meaning that each execution thread gets its own separate
-instance of the variable.
-This macro is used in header <CODE>softfloat.h</CODE> in the declarations of
-variables <CODE>softfloat_roundingMode</CODE>,
-<CODE>softfloat_detectTininess</CODE>, <CODE>extF80_roundingPrecision</CODE>,
-and <CODE>softfloat_exceptionFlags</CODE>.
-If macro <CODE>THREAD_LOCAL</CODE> is left undefined, these variables will
-default to being ordinary global variables.
-Depending on the compiler, possible valid definitions of this macro include
-<CODE>_Thread_local</CODE> and <CODE>__thread</CODE>.
-</DL>
-<DL>
-<DT><CODE>SOFTFLOAT_ROUND_ODD</CODE>
-<DD>
-Can be defined to enable support for optional rounding mode
-<CODE>softfloat_round_odd</CODE>.
-</DL>
-<DL>
-<DT><CODE>INLINE_LEVEL</CODE>
-<DD>
-Can be defined to an integer to determine the degree of inlining requested of
-the compiler.
-Larger numbers request that more inlining be done.
-If this macro is not defined or is defined to a value less <NOBR>than 1</NOBR>
-(zero or negative), no inlining is requested.
-The maximum effective value is no higher <NOBR>than 5</NOBR>.
-Defining this macro to a value greater than 5 is the same as defining it
-<NOBR>to 5</NOBR>.
-<DT><CODE>SOFTFLOAT_FAST_INT64</CODE>
-<DD>
-Can be defined to indicate that the build target&rsquo;s implementation of
-<NOBR>64-bit</NOBR> arithmetic is efficient.
-For newer <NOBR>64-bit</NOBR> processors, this macro should usually be defined.
-For very small microprocessors whose buses and registers are <NOBR>8-bit</NOBR>
-or <NOBR>16-bit</NOBR> in size, this macro should usually not be defined.
-Whether this macro should be defined for a <NOBR>32-bit</NOBR> processor may
-depend on the target machine and the applications that will use SoftFloat.
-<DT><CODE>SOFTFLOAT_FAST_DIV32TO16</CODE>
-<DD>
-Can be defined to indicate that the target&rsquo;s division operator
-<NOBR>in C</NOBR> (written as <CODE>/</CODE>) is reasonably efficient for
-dividing a <NOBR>32-bit</NOBR> unsigned integer by a <NOBR>16-bit</NOBR>
-unsigned integer.
-Setting this macro may affect the performance of function <CODE>f16_div</CODE>.
-<DT><CODE>SOFTFLOAT_FAST_DIV64TO32</CODE>
-<DD>
-Can be defined to indicate that the target&rsquo;s division operator
-<NOBR>in C</NOBR> (written as <CODE>/</CODE>) is reasonably efficient for
-dividing a <NOBR>64-bit</NOBR> unsigned integer by a <NOBR>32-bit</NOBR>
-unsigned integer.
-Setting this macro may affect the performance of division, remainder, and
-square root operations other than <CODE>f16_div</CODE>.
-</DL>
-</BLOCKQUOTE>
-</P>
-
-<P>
-Following the usual custom <NOBR>for C</NOBR>, for most of these macros (all
-except <CODE>INLINE</CODE>, <CODE>THREAD_LOCAL</CODE>, and
-<CODE>INLINE_LEVEL</CODE>), the content of any definition is irrelevant;
-what matters is a macro&rsquo;s effect on <CODE>#ifdef</CODE> directives.
-</P>
-
-<P>
-It is recommended that any definitions of macros <CODE>LITTLEENDIAN</CODE>,
-<CODE>INLINE</CODE>, and <CODE>THREAD_LOCAL</CODE> be made in a build
-target&rsquo;s <CODE>platform.h</CODE> header file, because these macros are
-expected to be determined inflexibly by the target machine and compiler.
-The other five macros select options and control optimization, and thus might
-be better located in the target&rsquo;s Makefile (or its equivalent).
-</P>
-
-
-<H3>5.4. Adapting a Template Target Directory</H3>
-
-<P>
-In the <CODE>build</CODE> directory, two <CODE>template</CODE> subdirectories
-provide models for new target directories.
-Two different templates exist because different functions are needed in the
-SoftFloat library depending on whether macro <CODE>SOFTFLOAT_FAST_INT64</CODE>
-is defined.
-If macro <CODE>SOFTFLOAT_FAST_INT64</CODE> will be defined,
-<NOBR><CODE>template-FAST_INT64</CODE></NOBR> is the template to use;
-otherwise, <NOBR><CODE>template-not-FAST_INT64</CODE></NOBR> is the appropriate
-template.
-A new target directory can be created by copying the correct template directory
-and editing the files inside.
-To avoid confusion, it would be wise to refrain from editing the files within a
-template directory directly.
-</P>
-
-
-<H3>5.5. Target-Specific Optimization of Primitive Functions</H3>
-
-<P>
-Header file <CODE>primitives.h</CODE> (in directory
-<CODE>source/include</CODE>) declares macros and functions for numerous
-underlying arithmetic operations upon which many of SoftFloat&rsquo;s
-floating-point functions are ultimately built.
-The SoftFloat sources include implementations of all of these functions/macros,
-written as standard C code, so a complete and correct SoftFloat library can be
-created using only the supplied code for all functions.
-However, for many targets, SoftFloat&rsquo;s performance can be improved by
-substituting target-specific implementations of some of the functions/macros
-declared in <CODE>primitives.h</CODE>.
-</P>
-
-<P>
-For example, <CODE>primitives.h</CODE> declares a function called
-<CODE>softfloat_countLeadingZeros32</CODE> that takes an unsigned
-<NOBR>32-bit</NOBR> integer as an argument and returns the number of the
-integer&rsquo;s most-significant bits that are zeros.
-While the SoftFloat sources include an implementation of this function written
-in <NOBR>standard C</NOBR>, many processors can perform this same function
-directly in only one or two machine instructions.
-An alternative, target-specific implementation that maps to those instructions
-is likely to be more efficient than the generic C code from the SoftFloat
-package.
-</P>
-
-<P>
-A build target can replace the supplied version of any function or macro of
-<CODE>primitives.h</CODE> by defining a macro with the same name in the
-target&rsquo;s <CODE>platform.h</CODE> header file.
-For this purpose, it may be helpful for <CODE>platform.h</CODE> to
-<CODE>#include</CODE> header file <CODE>primitiveTypes.h</CODE>, which defines
-types used for arguments and results of functions declared in
-<CODE>primitives.h</CODE>.
-When a desired replacement implementation is a function, not a macro, it is
-sufficient for <CODE>platform.h</CODE> to include the line
-<BLOCKQUOTE>
-<PRE>
-#define &lt;<I>function-name</I>&gt; &lt;<I>function-name</I>&gt;
-</PRE>
-</BLOCKQUOTE>
-where <NOBR><CODE>&lt;<I>function-name</I>&gt;</CODE></NOBR> is the name of the
-function.
-This technically defines <NOBR><CODE>&lt;<I>function-name</I>&gt;</CODE></NOBR>
-as a macro, but one that resolves to the same name, which may then be a
-function.
-(A preprocessor that conforms to the C Standard is required to limit recursive
-macro expansion from being applied more than once.)
-</P>
-
-<P>
-The supplied header file <CODE>opts-GCC.h</CODE> (in directory
-<CODE>source/include</CODE>) provides an example of target-specific
-optimization for the GCC compiler.
-Each GCC target example in the <CODE>build</CODE> directory has
-<BLOCKQUOTE>
-<CODE>#include "opts-GCC.h"</CODE>
-</BLOCKQUOTE>
-in its <CODE>platform.h</CODE> header file.
-Before <CODE>opts-GCC.h</CODE> is included, the following macros must be
-defined (or not) to control which features are invoked:
-<BLOCKQUOTE>
-<DL>
-<DT><CODE>SOFTFLOAT_BUILTIN_CLZ</CODE></DT>
-<DD>
-If defined, SoftFloat&rsquo;s internal
-&lsquo;<CODE>countLeadingZeros</CODE>&rsquo; functions use intrinsics
-<CODE>__builtin_clz</CODE> and <CODE>__builtin_clzll</CODE>.
-</DD>
-<DT><CODE>SOFTFLOAT_INTRINSIC_INT128</CODE></DT>
-<DD>
-If defined, SoftFloat makes use of GCC&rsquo;s nonstandard <NOBR>128-bit</NOBR>
-integer type <CODE>__int128</CODE>.
-</DD>
-</DL>
-</BLOCKQUOTE>
-On some machines, these improvements are observed to increase the speeds of
-<CODE>f64_mul</CODE> and <CODE>f128_mul</CODE> by around 20 to 25%, although
-other functions receive less dramatic boosts, or none at all.
-Results can vary greatly across different platforms.
-</P>
-
-
-<H2>6. Testing SoftFloat</H2>
-
-<P>
-SoftFloat can be tested using the <CODE>testsoftfloat</CODE> program by the
-same author.
-This program is part of the Berkeley TestFloat package available at the Web
-page
-<A HREF="http://www.jhauser.us/arithmetic/TestFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/TestFloat.html</CODE></NOBR></A>.
-The TestFloat package also has a program called <CODE>timesoftfloat</CODE> that
-measures the speed of SoftFloat&rsquo;s floating-point functions.
-</P>
-
-
-<H2>7. Providing SoftFloat as a Common Library for Applications</H2>
-
-<P>
-Header file <CODE>softfloat.h</CODE> defines the SoftFloat interface as seen by
-clients.
-If the SoftFloat library will be made a common library for programs on a
-system, the supplied <CODE>softfloat.h</CODE> has a couple of deficiencies for
-this purpose:
-<UL>
-<LI>
-As supplied, <CODE>softfloat.h</CODE> depends on another header,
-<CODE>softfloat_types.h</CODE>, that is not intended for public use but which
-must also be visible to the programmer&rsquo;s compiler.
-<LI>
-More troubling, at the time <CODE>softfloat.h</CODE> is included in a C source
-file, macros <CODE>SOFTFLOAT_FAST_INT64</CODE> and <CODE>THREAD_LOCAL</CODE>
-must be defined, or not defined, consistent with how these macro were defined
-when the SoftFloat library was built.
-</UL>
-In the situation that new programs may regularly <CODE>#include</CODE> header
-file <CODE>softfloat.h</CODE>, it is recommended that a custom, self-contained
-version of this header file be created that eliminates these issues.
-</P>
-
-
-<H2>8. Contact Information</H2>
-
-<P>
-At the time of this writing, the most up-to-date information about SoftFloat
-and the latest release can be found at the Web page
-<A HREF="http://www.jhauser.us/arithmetic/SoftFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/SoftFloat.html</CODE></NOBR></A>.
-</P>
-
-
-</BODY>
-
+
+<HTML>
+
+<HEAD>
+<TITLE>Berkeley SoftFloat Source Documentation</TITLE>
+</HEAD>
+
+<BODY>
+
+<H1>Berkeley SoftFloat Release 3e: Source Documentation</H1>
+
+<P>
+John R. Hauser<BR>
+2018 January 20<BR>
+</P>
+
+
+<H2>Contents</H2>
+
+<BLOCKQUOTE>
+<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
+<COL WIDTH=25>
+<COL WIDTH=*>
+<TR><TD COLSPAN=2>1. Introduction</TD></TR>
+<TR><TD COLSPAN=2>2. Limitations</TD></TR>
+<TR><TD COLSPAN=2>3. Acknowledgments and License</TD></TR>
+<TR><TD COLSPAN=2>4. SoftFloat Package Directory Structure</TD></TR>
+<TR><TD COLSPAN=2>5. Issues for Porting SoftFloat to a New Target</TD></TR>
+<TR>
+  <TD></TD>
+  <TD>5.1. Standard Headers <CODE>&lt;stdbool.h&gt;</CODE> and
+    <CODE>&lt;stdint.h&gt;</CODE></TD>
+</TR>
+<TR><TD></TD><TD>5.2. Specializing Floating-Point Behavior</TD></TR>
+<TR><TD></TD><TD>5.3. Macros for Build Options</TD></TR>
+<TR><TD></TD><TD>5.4. Adapting a Template Target Directory</TD></TR>
+<TR>
+  <TD></TD><TD>5.5. Target-Specific Optimization of Primitive Functions</TD>
+</TR>
+<TR><TD COLSPAN=2>6. Testing SoftFloat</TD></TR>
+<TR>
+  <TD COLSPAN=2>7. Providing SoftFloat as a Common Library for Applications</TD>
+</TR>
+<TR><TD COLSPAN=2>8. Contact Information</TD></TR>
+</TABLE>
+</BLOCKQUOTE>
+
+
+<H2>1. Introduction</H2>
+
+<P>
+This document gives information needed for compiling and/or porting Berkeley
+SoftFloat, a library of C functions implementing binary floating-point
+conforming to the IEEE Standard for Floating-Point Arithmetic.
+For basic documentation about SoftFloat refer to
+<A HREF="SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A>.
+</P>
+
+<P>
+The source code for SoftFloat is intended to be relatively machine-independent
+and should be compilable with any ISO-Standard C compiler that also supports
+<NOBR>64-bit</NOBR> integers.
+SoftFloat has been successfully compiled with the GNU C Compiler
+(<CODE>gcc</CODE>) for several platforms.
+</P>
+
+<P>
+<NOBR>Release 3</NOBR> of SoftFloat was a complete rewrite relative to
+<NOBR>Release 2</NOBR> or earlier.
+Changes to the interface of SoftFloat functions are documented in
+<A HREF="SoftFloat.html"><NOBR><CODE>SoftFloat.html</CODE></NOBR></A>.
+The current version of SoftFloat is <NOBR>Release 3e</NOBR>.
+</P>
+
+
+<H2>2. Limitations</H2>
+
+<P>
+SoftFloat assumes the computer has an addressable byte size of either 8 or
+<NOBR>16 bits</NOBR>.
+(Nearly all computers in use today have <NOBR>8-bit</NOBR> bytes.)
+</P>
+
+<P>
+SoftFloat is written in C and is designed to work with other C code.
+The C compiler used must conform at a minimum to the 1989 ANSI standard for the
+C language (same as the 1990 ISO standard) and must in addition support basic
+arithmetic on <NOBR>64-bit</NOBR> integers.
+Earlier releases of SoftFloat included implementations of <NOBR>32-bit</NOBR>
+single-precision and <NOBR>64-bit</NOBR> double-precision floating-point that
+did not require <NOBR>64-bit</NOBR> integers, but this option is not supported
+starting with <NOBR>Release 3</NOBR>.
+Since 1999, ISO standards for C have mandated compiler support for
+<NOBR>64-bit</NOBR> integers.
+A compiler conforming to the 1999 C Standard or later is recommended but not
+strictly required.
+</P>
+
+<P>
+<NOBR>C Standard</NOBR> header files <CODE>&lt;stdbool.h&gt;</CODE> and
+<CODE>&lt;stdint.h&gt;</CODE> are required for defining standard Boolean and
+integer types.
+If these headers are not supplied with the C compiler, minimal substitutes must
+be provided.
+SoftFloat&rsquo;s dependence on these headers is detailed later in
+<NOBR>section 5.1</NOBR>, <I>Standard Headers <CODE>&lt;stdbool.h&gt;</CODE>
+and <CODE>&lt;stdint.h&gt;</CODE></I>.
+</P>
+
+
+<H2>3. Acknowledgments and License</H2>
+
+<P>
+The SoftFloat package was written by me, <NOBR>John R.</NOBR> Hauser.
+<NOBR>Release 3</NOBR> of SoftFloat was a completely new implementation
+supplanting earlier releases.
+The project to create <NOBR>Release 3</NOBR> (now <NOBR>through 3e</NOBR>) was
+done in the employ of the University of California, Berkeley, within the
+Department of Electrical Engineering and Computer Sciences, first for the
+Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
+The work was officially overseen by Prof. Krste Asanovic, with funding provided
+by these sources:
+<BLOCKQUOTE>
+<TABLE>
+<COL>
+<COL WIDTH=10>
+<COL>
+<TR>
+<TD VALIGN=TOP><NOBR>Par Lab:</NOBR></TD>
+<TD></TD>
+<TD>
+Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
+(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
+NVIDIA, Oracle, and Samsung.
+</TD>
+</TR>
+<TR>
+<TD VALIGN=TOP><NOBR>ASPIRE Lab:</NOBR></TD>
+<TD></TD>
+<TD>
+DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
+ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
+Oracle, and Samsung.
+</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+The following applies to the whole of SoftFloat <NOBR>Release 3e</NOBR> as well
+as to each source file individually.
+</P>
+
+<P>
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.
+All rights reserved.
+</P>
+
+<P>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+<OL>
+
+<LI>
+<P>
+Redistributions of source code must retain the above copyright notice, this
+list of conditions, and the following disclaimer.
+</P>
+
+<LI>
+<P>
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions, and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+</P>
+
+<LI>
+<P>
+Neither the name of the University nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+</P>
+
+</OL>
+</P>
+
+<P>
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS &ldquo;AS IS&rdquo;,
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.
+IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+</P>
+
+
+<H2>4. SoftFloat Package Directory Structure</H2>
+
+<P>
+Because SoftFloat is targeted to multiple platforms, its source code is
+slightly scattered between target-specific and target-independent directories
+and files.
+The supplied directory structure is as follows:
+<BLOCKQUOTE>
+<PRE>
+doc
+source
+    include
+    8086
+    8086-SSE
+    ARM-VFPv2
+    ARM-VFPv2-defaultNaN
+build
+    template-FAST_INT64
+    template-not-FAST_INT64
+    Linux-386-GCC
+    Linux-386-SSE2-GCC
+    Linux-x86_64-GCC
+    Linux-ARM-VFPv2-GCC
+    Win32-MinGW
+    Win32-SSE2-MinGW
+    Win64-MinGW-w64
+</PRE>
+</BLOCKQUOTE>
+The majority of the SoftFloat sources are provided in the <CODE>source</CODE>
+directory.
+The <CODE>include</CODE> subdirectory contains several header files
+(unsurprisingly), while the other subdirectories of <CODE>source</CODE> contain
+source files that specialize the floating-point behavior to match particular
+processor families:
+<BLOCKQUOTE>
+<DL>
+<DT><CODE>8086</CODE></DT>
+<DD>
+Intel&rsquo;s older, 8087-derived floating-point, extended to all supported
+floating-point types
+</DD>
+<DT><CODE>8086-SSE</CODE></DT>
+<DD>
+Intel&rsquo;s x86 processors with Streaming SIMD Extensions (SSE) and later
+compatible extensions, having 8087 behavior for <NOBR>80-bit</NOBR>
+double-extended-precision (<CODE>extFloat80_t</CODE>) and SSE behavior for
+other floating-point types
+</DD>
+<DT><CODE>ARM-VFPv2</CODE></DT>
+<DD>
+ARM&rsquo;s VFPv2 or later floating-point, with NaN payload propagation
+</DD>
+<DT><CODE>ARM-VFPv2-defaultNaN</CODE></DT>
+<DD>
+ARM&rsquo;s VFPv2 or later floating-point, with the &ldquo;default NaN&rdquo;
+option
+</DD>
+</DL>
+</BLOCKQUOTE>
+If other specializations are attempted, these would be expected to be other
+subdirectories of <CODE>source</CODE> alongside the ones listed above.
+Specialization is covered later, in <NOBR>section 5.2</NOBR>, <I>Specializing
+Floating-Point Behavior</I>.
+</P>
+
+<P>
+The <CODE>build</CODE> directory is intended to contain a subdirectory for each
+target platform for which a build of the SoftFloat library may be created.
+For each build target, the target&rsquo;s subdirectory is where all derived
+object files and the completed SoftFloat library (typically
+<CODE>softfloat.a</CODE> or <CODE>libsoftfloat.a</CODE>) are created.
+The two <CODE>template</CODE> subdirectories are not actual build targets but
+contain sample files for creating new target directories.
+(The meaning of <CODE>FAST_INT64</CODE> will be explained later.)
+</P>
+
+<P>
+Ignoring the <CODE>template</CODE> directories, the supplied target directories
+are intended to follow a naming system of
+<NOBR><CODE>&lt;<I>execution-environment</I>&gt;-&lt;<I>compiler</I>&gt;</CODE></NOBR>.
+For the example targets,
+<NOBR><CODE>&lt;<I>execution-environment</I>&gt;</CODE></NOBR> is
+<NOBR><CODE>Linux-386</CODE></NOBR>, <NOBR><CODE>Linux-386-SSE2</CODE></NOBR>,
+<NOBR><CODE>Linux-x86_64</CODE></NOBR>,
+<NOBR><CODE>Linux-ARM-VFPv2</CODE></NOBR>, <CODE>Win32</CODE>,
+<NOBR><CODE>Win32-SSE2</CODE></NOBR>, or <CODE>Win64</CODE>, and
+<NOBR><CODE>&lt;<I>compiler</I>&gt;</CODE></NOBR> is <CODE>GCC</CODE>,
+<CODE>MinGW</CODE>, or <NOBR><CODE>MinGW-w64</CODE></NOBR>.
+</P>
+
+<P>
+All of the supplied target directories are merely examples that may or may not
+be correct for compiling on any particular system.
+Despite requests, there are currently no plans to include and maintain in the
+SoftFloat package the build files needed for a great many users&rsquo;
+compilation environments, which can span a huge range of operating systems,
+compilers, and other tools.
+</P>
+
+<P>
+As supplied, each target directory contains two files:
+<BLOCKQUOTE>
+<PRE>
+Makefile
+platform.h
+</PRE>
+</BLOCKQUOTE>
+The provided <CODE>Makefile</CODE> is written for GNU <CODE>make</CODE>.
+A build of SoftFloat for the specific target is begun by executing the
+<CODE>make</CODE> command with the target directory as the current directory.
+A completely different build tool can be used if an appropriate
+<CODE>Makefile</CODE> equivalent is created.
+</P>
+
+<P>
+The <CODE>platform.h</CODE> header file exists to provide a location for
+additional C declarations specific to the build target.
+Every C source file of SoftFloat contains a <CODE>#include</CODE> for
+<CODE>platform.h</CODE>.
+In many cases, the contents of <CODE>platform.h</CODE> can be as simple as one
+or two lines of code.
+At the other extreme, to get maximal performance from SoftFloat, it may be
+desirable to include in header <CODE>platform.h</CODE> (directly or via
+<CODE>#include</CODE>) declarations for numerous target-specific optimizations.
+Such possibilities are discussed in the next section, <I>Issues for Porting
+SoftFloat to a New Target</I>.
+If the target&rsquo;s compiler or library has bugs or other shortcomings,
+workarounds for these issues may also be possible with target-specific
+declarations in <CODE>platform.h</CODE>, avoiding the need to modify the main
+SoftFloat sources.
+</P>
+
+
+<H2>5. Issues for Porting SoftFloat to a New Target</H2>
+
+<H3>5.1. Standard Headers <CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE></H3>
+
+<P>
+The SoftFloat sources make use of standard headers
+<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE>, which have
+been part of the ISO C Standard Library since 1999.
+With any recent compiler, these standard headers are likely to be supported,
+even if the compiler does not claim complete conformance to the latest ISO C
+Standard.
+For older or nonstandard compilers, substitutes for
+<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE> may need to be
+created.
+SoftFloat depends on these names from <CODE>&lt;stdbool.h&gt;</CODE>:
+<BLOCKQUOTE>
+<PRE>
+bool
+true
+false
+</PRE>
+</BLOCKQUOTE>
+and on these names from <CODE>&lt;stdint.h&gt;</CODE>:
+<BLOCKQUOTE>
+<PRE>
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+UINT64_C
+INT64_C
+uint_least8_t
+uint_fast8_t
+uint_fast16_t
+uint_fast32_t
+uint_fast64_t
+int_fast8_t
+int_fast16_t
+int_fast32_t
+int_fast64_t
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+
+<H3>5.2. Specializing Floating-Point Behavior</H3>
+
+<P>
+The IEEE Floating-Point Standard allows for some flexibility in a conforming
+implementation, particularly concerning NaNs.
+The SoftFloat <CODE>source</CODE> directory is supplied with some
+<I>specialization</I> subdirectories containing possible definitions for this
+implementation-specific behavior.
+For example, the <CODE>8086</CODE> and <NOBR><CODE>8086-SSE</CODE></NOBR>
+subdirectories have source files that specialize SoftFloat&rsquo;s behavior to
+match that of Intel&rsquo;s x86 line of processors.
+The files in a specialization subdirectory must determine:
+<UL>
+<LI>
+whether tininess for underflow is detected before or after rounding by default;
+<LI>
+how signaling NaNs are distinguished from quiet NaNs;
+<LI>
+what (if anything) special happens when exceptions are raised;
+<LI>
+the default generated quiet NaNs;
+<LI>
+how NaNs are propagated from function inputs to output; and
+<LI>
+the integer results returned when conversions to integer type raise the
+<I>invalid</I> exception.
+</UL>
+</P>
+
+<P>
+As provided, the build process for a target expects to involve exactly
+<EM>one</EM> specialization directory that defines <EM>all</EM> of these
+implementation-specific details for the target.
+A specialization directory such as <CODE>8086</CODE> is expected to contain a
+header file called <CODE>specialize.h</CODE>, together with whatever other
+source files are needed to complete the specialization.
+</P>
+
+<P>
+A new build target may use an existing specialization, such as the ones
+provided by the <CODE>8086</CODE> and <NOBR><CODE>8086-SSE</CODE></NOBR>
+subdirectories.
+If a build target needs a new specialization, different from any existing ones,
+it is recommended that a new specialization directory be created for this
+purpose.
+The <CODE>specialize.h</CODE> header file from any of the provided
+specialization subdirectories can be used as a model for what definitions are
+needed.
+</P>
+
+
+<H3>5.3. Macros for Build Options</H3>
+
+<P>
+The SoftFloat source files adapt the floating-point implementation according to
+several C preprocessor macros:
+<BLOCKQUOTE>
+<DL>
+<DT><CODE>LITTLEENDIAN</CODE>
+<DD>
+Must be defined for little-endian machines; must not be defined for big-endian
+machines.
+<DT><CODE>INLINE</CODE>
+<DD>
+Specifies the sequence of tokens used to indicate that a C function should be
+inlined.
+If macro <CODE>INLINE_LEVEL</CODE> is defined with a value of 1 or higher, this
+macro must be defined; otherwise, this macro is ignored and need not be
+defined.
+For compilers that conform to the C Standard&rsquo;s rules for inline
+functions, this macro can be defined as the single keyword <CODE>inline</CODE>.
+For other compilers that follow a convention pre-dating the standardization of
+<CODE>inline</CODE>, this macro may need to be defined to <CODE>extern</CODE>
+<CODE>inline</CODE>.
+<DT><CODE>THREAD_LOCAL</CODE>
+<DD>
+Can be defined to a sequence of tokens that, when appearing at the start of a
+variable declaration, indicates to the C compiler that the variable is
+<I>per-thread</I>, meaning that each execution thread gets its own separate
+instance of the variable.
+This macro is used in header <CODE>softfloat.h</CODE> in the declarations of
+variables <CODE>softfloat_roundingMode</CODE>,
+<CODE>softfloat_detectTininess</CODE>, <CODE>extF80_roundingPrecision</CODE>,
+and <CODE>softfloat_exceptionFlags</CODE>.
+If macro <CODE>THREAD_LOCAL</CODE> is left undefined, these variables will
+default to being ordinary global variables.
+Depending on the compiler, possible valid definitions of this macro include
+<CODE>_Thread_local</CODE> and <CODE>__thread</CODE>.
+</DL>
+<DL>
+<DT><CODE>SOFTFLOAT_ROUND_ODD</CODE>
+<DD>
+Can be defined to enable support for optional rounding mode
+<CODE>softfloat_round_odd</CODE>.
+</DL>
+<DL>
+<DT><CODE>INLINE_LEVEL</CODE>
+<DD>
+Can be defined to an integer to determine the degree of inlining requested of
+the compiler.
+Larger numbers request that more inlining be done.
+If this macro is not defined or is defined to a value less <NOBR>than 1</NOBR>
+(zero or negative), no inlining is requested.
+The maximum effective value is no higher <NOBR>than 5</NOBR>.
+Defining this macro to a value greater than 5 is the same as defining it
+<NOBR>to 5</NOBR>.
+<DT><CODE>SOFTFLOAT_FAST_INT64</CODE>
+<DD>
+Can be defined to indicate that the build target&rsquo;s implementation of
+<NOBR>64-bit</NOBR> arithmetic is efficient.
+For newer <NOBR>64-bit</NOBR> processors, this macro should usually be defined.
+For very small microprocessors whose buses and registers are <NOBR>8-bit</NOBR>
+or <NOBR>16-bit</NOBR> in size, this macro should usually not be defined.
+Whether this macro should be defined for a <NOBR>32-bit</NOBR> processor may
+depend on the target machine and the applications that will use SoftFloat.
+<DT><CODE>SOFTFLOAT_FAST_DIV32TO16</CODE>
+<DD>
+Can be defined to indicate that the target&rsquo;s division operator
+<NOBR>in C</NOBR> (written as <CODE>/</CODE>) is reasonably efficient for
+dividing a <NOBR>32-bit</NOBR> unsigned integer by a <NOBR>16-bit</NOBR>
+unsigned integer.
+Setting this macro may affect the performance of function <CODE>f16_div</CODE>.
+<DT><CODE>SOFTFLOAT_FAST_DIV64TO32</CODE>
+<DD>
+Can be defined to indicate that the target&rsquo;s division operator
+<NOBR>in C</NOBR> (written as <CODE>/</CODE>) is reasonably efficient for
+dividing a <NOBR>64-bit</NOBR> unsigned integer by a <NOBR>32-bit</NOBR>
+unsigned integer.
+Setting this macro may affect the performance of division, remainder, and
+square root operations other than <CODE>f16_div</CODE>.
+</DL>
+</BLOCKQUOTE>
+</P>
+
+<P>
+Following the usual custom <NOBR>for C</NOBR>, for most of these macros (all
+except <CODE>INLINE</CODE>, <CODE>THREAD_LOCAL</CODE>, and
+<CODE>INLINE_LEVEL</CODE>), the content of any definition is irrelevant;
+what matters is a macro&rsquo;s effect on <CODE>#ifdef</CODE> directives.
+</P>
+
+<P>
+It is recommended that any definitions of macros <CODE>LITTLEENDIAN</CODE>,
+<CODE>INLINE</CODE>, and <CODE>THREAD_LOCAL</CODE> be made in a build
+target&rsquo;s <CODE>platform.h</CODE> header file, because these macros are
+expected to be determined inflexibly by the target machine and compiler.
+The other five macros select options and control optimization, and thus might
+be better located in the target&rsquo;s Makefile (or its equivalent).
+</P>
+
+
+<H3>5.4. Adapting a Template Target Directory</H3>
+
+<P>
+In the <CODE>build</CODE> directory, two <CODE>template</CODE> subdirectories
+provide models for new target directories.
+Two different templates exist because different functions are needed in the
+SoftFloat library depending on whether macro <CODE>SOFTFLOAT_FAST_INT64</CODE>
+is defined.
+If macro <CODE>SOFTFLOAT_FAST_INT64</CODE> will be defined,
+<NOBR><CODE>template-FAST_INT64</CODE></NOBR> is the template to use;
+otherwise, <NOBR><CODE>template-not-FAST_INT64</CODE></NOBR> is the appropriate
+template.
+A new target directory can be created by copying the correct template directory
+and editing the files inside.
+To avoid confusion, it would be wise to refrain from editing the files within a
+template directory directly.
+</P>
+
+
+<H3>5.5. Target-Specific Optimization of Primitive Functions</H3>
+
+<P>
+Header file <CODE>primitives.h</CODE> (in directory
+<CODE>source/include</CODE>) declares macros and functions for numerous
+underlying arithmetic operations upon which many of SoftFloat&rsquo;s
+floating-point functions are ultimately built.
+The SoftFloat sources include implementations of all of these functions/macros,
+written as standard C code, so a complete and correct SoftFloat library can be
+created using only the supplied code for all functions.
+However, for many targets, SoftFloat&rsquo;s performance can be improved by
+substituting target-specific implementations of some of the functions/macros
+declared in <CODE>primitives.h</CODE>.
+</P>
+
+<P>
+For example, <CODE>primitives.h</CODE> declares a function called
+<CODE>softfloat_countLeadingZeros32</CODE> that takes an unsigned
+<NOBR>32-bit</NOBR> integer as an argument and returns the number of the
+integer&rsquo;s most-significant bits that are zeros.
+While the SoftFloat sources include an implementation of this function written
+in <NOBR>standard C</NOBR>, many processors can perform this same function
+directly in only one or two machine instructions.
+An alternative, target-specific implementation that maps to those instructions
+is likely to be more efficient than the generic C code from the SoftFloat
+package.
+</P>
+
+<P>
+A build target can replace the supplied version of any function or macro of
+<CODE>primitives.h</CODE> by defining a macro with the same name in the
+target&rsquo;s <CODE>platform.h</CODE> header file.
+For this purpose, it may be helpful for <CODE>platform.h</CODE> to
+<CODE>#include</CODE> header file <CODE>primitiveTypes.h</CODE>, which defines
+types used for arguments and results of functions declared in
+<CODE>primitives.h</CODE>.
+When a desired replacement implementation is a function, not a macro, it is
+sufficient for <CODE>platform.h</CODE> to include the line
+<BLOCKQUOTE>
+<PRE>
+#define &lt;<I>function-name</I>&gt; &lt;<I>function-name</I>&gt;
+</PRE>
+</BLOCKQUOTE>
+where <NOBR><CODE>&lt;<I>function-name</I>&gt;</CODE></NOBR> is the name of the
+function.
+This technically defines <NOBR><CODE>&lt;<I>function-name</I>&gt;</CODE></NOBR>
+as a macro, but one that resolves to the same name, which may then be a
+function.
+(A preprocessor that conforms to the C Standard is required to limit recursive
+macro expansion from being applied more than once.)
+</P>
+
+<P>
+The supplied header file <CODE>opts-GCC.h</CODE> (in directory
+<CODE>source/include</CODE>) provides an example of target-specific
+optimization for the GCC compiler.
+Each GCC target example in the <CODE>build</CODE> directory has
+<BLOCKQUOTE>
+<CODE>#include "opts-GCC.h"</CODE>
+</BLOCKQUOTE>
+in its <CODE>platform.h</CODE> header file.
+Before <CODE>opts-GCC.h</CODE> is included, the following macros must be
+defined (or not) to control which features are invoked:
+<BLOCKQUOTE>
+<DL>
+<DT><CODE>SOFTFLOAT_BUILTIN_CLZ</CODE></DT>
+<DD>
+If defined, SoftFloat&rsquo;s internal
+&lsquo;<CODE>countLeadingZeros</CODE>&rsquo; functions use intrinsics
+<CODE>__builtin_clz</CODE> and <CODE>__builtin_clzll</CODE>.
+</DD>
+<DT><CODE>SOFTFLOAT_INTRINSIC_INT128</CODE></DT>
+<DD>
+If defined, SoftFloat makes use of GCC&rsquo;s nonstandard <NOBR>128-bit</NOBR>
+integer type <CODE>__int128</CODE>.
+</DD>
+</DL>
+</BLOCKQUOTE>
+On some machines, these improvements are observed to increase the speeds of
+<CODE>f64_mul</CODE> and <CODE>f128_mul</CODE> by around 20 to 25%, although
+other functions receive less dramatic boosts, or none at all.
+Results can vary greatly across different platforms.
+</P>
+
+
+<H2>6. Testing SoftFloat</H2>
+
+<P>
+SoftFloat can be tested using the <CODE>testsoftfloat</CODE> program by the
+same author.
+This program is part of the Berkeley TestFloat package available at the Web
+page
+<A HREF="http://www.jhauser.us/arithmetic/TestFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/TestFloat.html</CODE></NOBR></A>.
+The TestFloat package also has a program called <CODE>timesoftfloat</CODE> that
+measures the speed of SoftFloat&rsquo;s floating-point functions.
+</P>
+
+
+<H2>7. Providing SoftFloat as a Common Library for Applications</H2>
+
+<P>
+Header file <CODE>softfloat.h</CODE> defines the SoftFloat interface as seen by
+clients.
+If the SoftFloat library will be made a common library for programs on a
+system, the supplied <CODE>softfloat.h</CODE> has a couple of deficiencies for
+this purpose:
+<UL>
+<LI>
+As supplied, <CODE>softfloat.h</CODE> depends on another header,
+<CODE>softfloat_types.h</CODE>, that is not intended for public use but which
+must also be visible to the programmer&rsquo;s compiler.
+<LI>
+More troubling, at the time <CODE>softfloat.h</CODE> is included in a C source
+file, macros <CODE>SOFTFLOAT_FAST_INT64</CODE> and <CODE>THREAD_LOCAL</CODE>
+must be defined, or not defined, consistent with how these macro were defined
+when the SoftFloat library was built.
+</UL>
+In the situation that new programs may regularly <CODE>#include</CODE> header
+file <CODE>softfloat.h</CODE>, it is recommended that a custom, self-contained
+version of this header file be created that eliminates these issues.
+</P>
+
+
+<H2>8. Contact Information</H2>
+
+<P>
+At the time of this writing, the most up-to-date information about SoftFloat
+and the latest release can be found at the Web page
+<A HREF="http://www.jhauser.us/arithmetic/SoftFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/SoftFloat.html</CODE></NOBR></A>.
+</P>
+
+
+</BODY>
+
diff --git a/softfloat/doc/SoftFloat.html b/softfloat/doc/SoftFloat.html
index bb41770..8367d6f 100644
--- a/softfloat/doc/SoftFloat.html
+++ b/softfloat/doc/SoftFloat.html
@@ -1,1527 +1,1527 @@
-
-<HTML>
-
-<HEAD>
-<TITLE>Berkeley SoftFloat Library Interface</TITLE>
-</HEAD>
-
-<BODY>
-
-<H1>Berkeley SoftFloat Release 3e: Library Interface</H1>
-
-<P>
-John R. Hauser<BR>
-2018 January 20<BR>
-</P>
-
-
-<H2>Contents</H2>
-
-<BLOCKQUOTE>
-<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
-<COL WIDTH=25>
-<COL WIDTH=*>
-<TR><TD COLSPAN=2>1. Introduction</TD></TR>
-<TR><TD COLSPAN=2>2. Limitations</TD></TR>
-<TR><TD COLSPAN=2>3. Acknowledgments and License</TD></TR>
-<TR><TD COLSPAN=2>4. Types and Functions</TD></TR>
-<TR><TD></TD><TD>4.1. Boolean and Integer Types</TD></TR>
-<TR><TD></TD><TD>4.2. Floating-Point Types</TD></TR>
-<TR><TD></TD><TD>4.3. Supported Floating-Point Functions</TD></TR>
-<TR>
-  <TD></TD>
-  <TD>4.4. Non-canonical Representations in <CODE>extFloat80_t</CODE></TD>
-</TR>
-<TR><TD></TD><TD>4.5. Conventions for Passing Arguments and Results</TD></TR>
-<TR><TD COLSPAN=2>5. Reserved Names</TD></TR>
-<TR><TD COLSPAN=2>6. Mode Variables</TD></TR>
-<TR><TD></TD><TD>6.1. Rounding Mode</TD></TR>
-<TR><TD></TD><TD>6.2. Underflow Detection</TD></TR>
-<TR>
-  <TD></TD>
-  <TD>6.3. Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</TD>
-</TR>
-<TR><TD COLSPAN=2>7. Exceptions and Exception Flags</TD></TR>
-<TR><TD COLSPAN=2>8. Function Details</TD></TR>
-<TR><TD></TD><TD>8.1. Conversions from Integer to Floating-Point</TD></TR>
-<TR><TD></TD><TD>8.2. Conversions from Floating-Point to Integer</TD></TR>
-<TR><TD></TD><TD>8.3. Conversions Among Floating-Point Types</TD></TR>
-<TR><TD></TD><TD>8.4. Basic Arithmetic Functions</TD></TR>
-<TR><TD></TD><TD>8.5. Fused Multiply-Add Functions</TD></TR>
-<TR><TD></TD><TD>8.6. Remainder Functions</TD></TR>
-<TR><TD></TD><TD>8.7. Round-to-Integer Functions</TD></TR>
-<TR><TD></TD><TD>8.8. Comparison Functions</TD></TR>
-<TR><TD></TD><TD>8.9. Signaling NaN Test Functions</TD></TR>
-<TR><TD></TD><TD>8.10. Raise-Exception Function</TD></TR>
-<TR><TD COLSPAN=2>9. Changes from SoftFloat <NOBR>Release 2</NOBR></TD></TR>
-<TR><TD></TD><TD>9.1. Name Changes</TD></TR>
-<TR><TD></TD><TD>9.2. Changes to Function Arguments</TD></TR>
-<TR><TD></TD><TD>9.3. Added Capabilities</TD></TR>
-<TR><TD></TD><TD>9.4. Better Compatibility with the C Language</TD></TR>
-<TR><TD></TD><TD>9.5. New Organization as a Library</TD></TR>
-<TR><TD></TD><TD>9.6. Optimization Gains (and Losses)</TD></TR>
-<TR><TD COLSPAN=2>10. Future Directions</TD></TR>
-<TR><TD COLSPAN=2>11. Contact Information</TD></TR>
-</TABLE>
-</BLOCKQUOTE>
-
-
-<H2>1. Introduction</H2>
-
-<P>
-Berkeley SoftFloat is a software implementation of binary floating-point that
-conforms to the IEEE Standard for Floating-Point Arithmetic.
-The current release supports five binary formats:  <NOBR>16-bit</NOBR>
-half-precision, <NOBR>32-bit</NOBR> single-precision, <NOBR>64-bit</NOBR>
-double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
-<NOBR>128-bit</NOBR> quadruple-precision.
-The following functions are supported for each format:
-<UL>
-<LI>
-addition, subtraction, multiplication, division, and square root;
-<LI>
-fused multiply-add as defined by the IEEE Standard, except for
-<NOBR>80-bit</NOBR> double-extended-precision;
-<LI>
-remainder as defined by the IEEE Standard;
-<LI>
-round to integral value;
-<LI>
-comparisons;
-<LI>
-conversions to/from other supported formats; and
-<LI>
-conversions to/from <NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> integers,
-signed and unsigned.
-</UL>
-All operations required by the original 1985 version of the IEEE Floating-Point
-Standard are implemented, except for conversions to and from decimal.
-</P>
-
-<P>
-This document gives information about the types defined and the routines
-implemented by SoftFloat.
-It does not attempt to define or explain the IEEE Floating-Point Standard.
-Information about the standard is available elsewhere.
-</P>
-
-<P>
-The current version of SoftFloat is <NOBR>Release 3e</NOBR>.
-This release modifies the behavior of the rarely used <I>odd</I> rounding mode
-(<I>round to odd</I>, also known as <I>jamming</I>), and also adds some new
-specialization and optimization examples for those compiling SoftFloat.
-</P>
-
-<P>
-The previous <NOBR>Release 3d</NOBR> fixed bugs that were found in the square
-root functions for the <NOBR>64-bit</NOBR>, <NOBR>80-bit</NOBR>, and
-<NOBR>128-bit</NOBR> floating-point formats.
-(Thanks to Alexei Sibidanov at the University of Victoria for reporting an
-incorrect result.)
-The bugs affected all prior <NOBR>Release-3</NOBR> versions of SoftFloat
-<NOBR>through 3c</NOBR>.
-The flaw in the <NOBR>64-bit</NOBR> floating-point square root function was of
-very minor impact, causing a <NOBR>1-ulp</NOBR> error (<NOBR>1 unit</NOBR> in
-the last place) a few times out of a billion.
-The bugs in the <NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> square root
-functions were more serious.
-Although incorrect results again occurred only a few times out of a billion,
-when they did occur a large portion of the less-significant bits could be
-wrong.
-</P>
-
-<P>
-Among earlier releases, 3b was notable for adding support for the
-<NOBR>16-bit</NOBR> half-precision format.
-For more about the evolution of SoftFloat releases, see
-<A HREF="SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></NOBR></A>.
-</P>
-
-<P>
-The functional interface of SoftFloat <NOBR>Release 3</NOBR> and later differs
-in many details from the releases that came before.
-For specifics of these differences, see <NOBR>section 9</NOBR> below,
-<I>Changes from SoftFloat <NOBR>Release 2</NOBR></I>.
-</P>
-
-
-<H2>2. Limitations</H2>
-
-<P>
-SoftFloat assumes the computer has an addressable byte size of 8 or
-<NOBR>16 bits</NOBR>.
-(Nearly all computers in use today have <NOBR>8-bit</NOBR> bytes.)
-</P>
-
-<P>
-SoftFloat is written in C and is designed to work with other C code.
-The C compiler used must conform at a minimum to the 1989 ANSI standard for the
-C language (same as the 1990 ISO standard) and must in addition support basic
-arithmetic on <NOBR>64-bit</NOBR> integers.
-Earlier releases of SoftFloat included implementations of <NOBR>32-bit</NOBR>
-single-precision and <NOBR>64-bit</NOBR> double-precision floating-point that
-did not require <NOBR>64-bit</NOBR> integers, but this option is not supported
-starting with <NOBR>Release 3</NOBR>.
-Since 1999, ISO standards for C have mandated compiler support for
-<NOBR>64-bit</NOBR> integers.
-A compiler conforming to the 1999 C Standard or later is recommended but not
-strictly required.
-</P>
-
-<P>
-Most operations not required by the original 1985 version of the IEEE
-Floating-Point Standard but added in the 2008 version are not yet supported in
-SoftFloat <NOBR>Release 3e</NOBR>.
-</P>
-
-
-<H2>3. Acknowledgments and License</H2>
-
-<P>
-The SoftFloat package was written by me, <NOBR>John R.</NOBR> Hauser.
-<NOBR>Release 3</NOBR> of SoftFloat was a completely new implementation
-supplanting earlier releases.
-The project to create <NOBR>Release 3</NOBR> (now <NOBR>through 3e</NOBR>) was
-done in the employ of the University of California, Berkeley, within the
-Department of Electrical Engineering and Computer Sciences, first for the
-Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
-The work was officially overseen by Prof. Krste Asanovic, with funding provided
-by these sources:
-<BLOCKQUOTE>
-<TABLE>
-<COL>
-<COL WIDTH=10>
-<COL>
-<TR>
-<TD VALIGN=TOP><NOBR>Par Lab:</NOBR></TD>
-<TD></TD>
-<TD>
-Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
-(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
-NVIDIA, Oracle, and Samsung.
-</TD>
-</TR>
-<TR>
-<TD VALIGN=TOP><NOBR>ASPIRE Lab:</NOBR></TD>
-<TD></TD>
-<TD>
-DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
-ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
-Oracle, and Samsung.
-</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-The following applies to the whole of SoftFloat <NOBR>Release 3e</NOBR> as well
-as to each source file individually.
-</P>
-
-<P>
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.
-All rights reserved.
-</P>
-
-<P>
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-<OL>
-
-<LI>
-<P>
-Redistributions of source code must retain the above copyright notice, this
-list of conditions, and the following disclaimer.
-</P>
-
-<LI>
-<P>
-Redistributions in binary form must reproduce the above copyright notice, this
-list of conditions, and the following disclaimer in the documentation and/or
-other materials provided with the distribution.
-</P>
-
-<LI>
-<P>
-Neither the name of the University nor the names of its contributors may be
-used to endorse or promote products derived from this software without specific
-prior written permission.
-</P>
-
-</OL>
-</P>
-
-<P>
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS &ldquo;AS IS&rdquo;,
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.
-IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-</P>
-
-
-<H2>4. Types and Functions</H2>
-
-<P>
-The types and functions of SoftFloat are declared in header file
-<CODE>softfloat.h</CODE>.
-</P>
-
-<H3>4.1. Boolean and Integer Types</H3>
-
-<P>
-Header file <CODE>softfloat.h</CODE> depends on standard headers
-<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE> to define type
-<CODE>bool</CODE> and several integer types.
-These standard headers have been part of the ISO C Standard Library since 1999.
-With any recent compiler, they are likely to be supported, even if the compiler
-does not claim complete conformance to the latest ISO C Standard.
-For older or nonstandard compilers, a port of SoftFloat may have substitutes
-for these headers.
-Header <CODE>softfloat.h</CODE> depends only on the name <CODE>bool</CODE> from
-<CODE>&lt;stdbool.h&gt;</CODE> and on these type names from
-<CODE>&lt;stdint.h&gt;</CODE>:
-<BLOCKQUOTE>
-<PRE>
-uint16_t
-uint32_t
-uint64_t
-int32_t
-int64_t
-uint_fast8_t
-uint_fast32_t
-uint_fast64_t
-int_fast32_t
-int_fast64_t
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-
-<H3>4.2. Floating-Point Types</H3>
-
-<P>
-The <CODE>softfloat.h</CODE> header defines five floating-point types:
-<BLOCKQUOTE>
-<TABLE CELLSPACING=0 CELLPADDING=0>
-<TR>
-<TD><CODE>float16_t</CODE></TD>
-<TD><NOBR>16-bit</NOBR> half-precision binary format</TD>
-</TR>
-<TR>
-<TD><CODE>float32_t</CODE></TD>
-<TD><NOBR>32-bit</NOBR> single-precision binary format</TD>
-</TR>
-<TR>
-<TD><CODE>float64_t</CODE></TD>
-<TD><NOBR>64-bit</NOBR> double-precision binary format</TD>
-</TR>
-<TR>
-<TD><CODE>extFloat80_t&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD><NOBR>80-bit</NOBR> double-extended-precision binary format (old Intel or
-Motorola format)</TD>
-</TR>
-<TR>
-<TD><CODE>float128_t</CODE></TD>
-<TD><NOBR>128-bit</NOBR> quadruple-precision binary format</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-The non-extended types are each exactly the size specified:
-<NOBR>16 bits</NOBR> for <CODE>float16_t</CODE>, <NOBR>32 bits</NOBR> for
-<CODE>float32_t</CODE>, <NOBR>64 bits</NOBR> for <CODE>float64_t</CODE>, and
-<NOBR>128 bits</NOBR> for <CODE>float128_t</CODE>.
-Aside from these size requirements, the definitions of all these types may
-differ for different ports of SoftFloat to specific systems.
-A given port of SoftFloat may or may not define some of the floating-point
-types as aliases for the C standard types <CODE>float</CODE>,
-<CODE>double</CODE>, and <CODE>long</CODE> <CODE>double</CODE>.
-</P>
-
-<P>
-Header file <CODE>softfloat.h</CODE> also defines a structure,
-<CODE>struct</CODE> <CODE>extFloat80M</CODE>, for the representation of
-<NOBR>80-bit</NOBR> double-extended-precision floating-point values in memory.
-This structure is the same size as type <CODE>extFloat80_t</CODE> and contains
-at least these two fields (not necessarily in this order):
-<BLOCKQUOTE>
-<PRE>
-uint16_t signExp;
-uint64_t signif;
-</PRE>
-</BLOCKQUOTE>
-Field <CODE>signExp</CODE> contains the sign and exponent of the floating-point
-value, with the sign in the most significant bit (<NOBR>bit 15</NOBR>) and the
-encoded exponent in the other <NOBR>15 bits</NOBR>.
-Field <CODE>signif</CODE> is the complete <NOBR>64-bit</NOBR> significand of
-the floating-point value.
-(In the usual encoding for <NOBR>80-bit</NOBR> extended floating-point, the
-leading <NOBR>1 bit</NOBR> of normalized numbers is not implicit but is stored
-in the most significant bit of the significand.)
-</P>
-
-<H3>4.3. Supported Floating-Point Functions</H3>
-
-<P>
-SoftFloat implements these arithmetic operations for its floating-point types:
-<UL>
-<LI>
-conversions between any two floating-point formats;
-<LI>
-for each floating-point format, conversions to and from signed and unsigned
-<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> integers;
-<LI>
-for each format, the usual addition, subtraction, multiplication, division, and
-square root operations;
-<LI>
-for each format except <CODE>extFloat80_t</CODE>, the fused multiply-add
-operation defined by the IEEE Standard;
-<LI>
-for each format, the floating-point remainder operation defined by the IEEE
-Standard;
-<LI>
-for each format, a &ldquo;round to integer&rdquo; operation that rounds to the
-nearest integer value in the same format; and
-<LI>
-comparisons between two values in the same floating-point format.
-</UL>
-</P>
-
-<P>
-The following operations required by the 2008 IEEE Floating-Point Standard are
-not supported in SoftFloat <NOBR>Release 3e</NOBR>:
-<UL>
-<LI>
-<B>nextUp</B>, <B>nextDown</B>, <B>minNum</B>, <B>maxNum</B>, <B>minNumMag</B>,
-<B>maxNumMag</B>, <B>scaleB</B>, and <B>logB</B>;
-<LI>
-conversions between floating-point formats and decimal or hexadecimal character
-sequences;
-<LI>
-all &ldquo;quiet-computation&rdquo; operations (<B>copy</B>, <B>negate</B>,
-<B>abs</B>, and <B>copySign</B>, which all involve only simple copying and/or
-manipulation of the floating-point sign bit); and
-<LI>
-all &ldquo;non-computational&rdquo; operations other than <B>isSignaling</B>
-(which is supported).
-</UL>
-</P>
-
-<H3>4.4. Non-canonical Representations in <CODE>extFloat80_t</CODE></H3>
-
-<P>
-Because the <NOBR>80-bit</NOBR> double-extended-precision format,
-<CODE>extFloat80_t</CODE>, stores an explicit leading significand bit, many
-finite floating-point numbers are encodable in this type in multiple equivalent
-forms.
-Of these multiple encodings, there is always a unique one with the least
-encoded exponent value, and this encoding is considered the <I>canonical</I>
-representation of the floating-point number.
-Any other equivalent representations (having a higher encoded exponent value)
-are <I>non-canonical</I>.
-For a value in the subnormal range (including zero), the canonical
-representation always has an encoded exponent of zero and a leading significand
-bit <NOBR>of 0</NOBR>.
-For finite values outside the subnormal range, the canonical representation
-always has an encoded exponent that is nonzero and a leading significand bit
-<NOBR>of 1</NOBR>.
-</P>
-
-<P>
-For an infinity or NaN, the leading significand bit is similarly expected to
-<NOBR>be 1</NOBR>.
-An infinity or NaN with a leading significand bit <NOBR>of 0</NOBR> is again
-considered non-canonical.
-Hence, altogether, to be canonical, a value of type <CODE>extFloat80_t</CODE>
-must have a leading significand bit <NOBR>of 1</NOBR>, unless the value is
-subnormal or zero, in which case the leading significand bit and the encoded
-exponent must both be zero.
-</P>
-
-<P>
-SoftFloat&rsquo;s functions are not guaranteed to operate as expected when
-inputs of type <CODE>extFloat80_t</CODE> are non-canonical.
-Assuming all of a function&rsquo;s <CODE>extFloat80_t</CODE> inputs (if any)
-are canonical, function outputs of type <CODE>extFloat80_t</CODE> will always
-be canonical.
-</P>
-
-<H3>4.5. Conventions for Passing Arguments and Results</H3>
-
-<P>
-Values that are at most <NOBR>64 bits</NOBR> in size (i.e., not the
-<NOBR>80-bit</NOBR> or <NOBR>128-bit</NOBR> floating-point formats) are in all
-cases passed as function arguments by value.
-Likewise, when an output of a function is no more than <NOBR>64 bits</NOBR>, it
-is always returned directly as the function result.
-Thus, for example, the SoftFloat function for adding two <NOBR>64-bit</NOBR>
-floating-point values has this simple signature:
-<BLOCKQUOTE>
-<CODE>float64_t f64_add( float64_t, float64_t );</CODE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-The story is more complex when function inputs and outputs are
-<NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> floating-point.
-For these types, SoftFloat always provides a function that passes these larger
-values into or out of the function indirectly, via pointers.
-For example, for adding two <NOBR>128-bit</NOBR> floating-point values,
-SoftFloat supplies this function:
-<BLOCKQUOTE>
-<CODE>void f128M_add( const float128_t *, const float128_t *, float128_t * );</CODE>
-</BLOCKQUOTE>
-The first two arguments point to the values to be added, and the last argument
-points to the location where the sum will be stored.
-The <CODE>M</CODE> in the name <CODE>f128M_add</CODE> is mnemonic for the fact
-that the <NOBR>128-bit</NOBR> inputs and outputs are &ldquo;in memory&rdquo;,
-pointed to by pointer arguments.
-</P>
-
-<P>
-All ports of SoftFloat implement these <I>pass-by-pointer</I> functions for
-types <CODE>extFloat80_t</CODE> and <CODE>float128_t</CODE>.
-At the same time, SoftFloat ports may also implement alternate versions of
-these same functions that pass <CODE>extFloat80_t</CODE> and
-<CODE>float128_t</CODE> by value, like the smaller formats.
-Thus, besides the function with name <CODE>f128M_add</CODE> shown above, a
-SoftFloat port may also supply an equivalent function with this signature:
-<BLOCKQUOTE>
-<CODE>float128_t f128_add( float128_t, float128_t );</CODE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-As a general rule, on computers where the machine word size is
-<NOBR>32 bits</NOBR> or smaller, only the pass-by-pointer versions of functions
-(e.g., <CODE>f128M_add</CODE>) are provided for types <CODE>extFloat80_t</CODE>
-and <CODE>float128_t</CODE>, because passing such large types directly can have
-significant extra cost.
-On computers where the word size is <NOBR>64 bits</NOBR> or larger, both
-function versions (<CODE>f128M_add</CODE> and <CODE>f128_add</CODE>) are
-provided, because the cost of passing by value is then more reasonable.
-Applications that must be portable accross both classes of computers must use
-the pointer-based functions, as these are always implemented.
-However, if it is known that SoftFloat includes the by-value functions for all
-platforms of interest, programmers can use whichever version they prefer.
-</P>
-
-
-<H2>5. Reserved Names</H2>
-
-<P>
-In addition to the variables and functions documented here, SoftFloat defines
-some symbol names for its own private use.
-These private names always begin with the prefix
-&lsquo;<CODE>softfloat_</CODE>&rsquo;.
-When a program includes header <CODE>softfloat.h</CODE> or links with the
-SoftFloat library, all names with prefix &lsquo;<CODE>softfloat_</CODE>&rsquo;
-are reserved for possible use by SoftFloat.
-Applications that use SoftFloat should not define their own names with this
-prefix, and should reference only such names as are documented.
-</P>
-
-
-<H2>6. Mode Variables</H2>
-
-<P>
-The following global variables control rounding mode, underflow detection, and
-the <NOBR>80-bit</NOBR> extended format&rsquo;s rounding precision:
-<BLOCKQUOTE>
-<CODE>softfloat_roundingMode</CODE><BR>
-<CODE>softfloat_detectTininess</CODE><BR>
-<CODE>extF80_roundingPrecision</CODE>
-</BLOCKQUOTE>
-These mode variables are covered in the next several subsections.
-For some SoftFloat ports, these variables may be <I>per-thread</I> (declared
-<CODE>thread_local</CODE>), meaning that different execution threads have their
-own separate copies of the variables.
-</P>
-
-<H3>6.1. Rounding Mode</H3>
-
-<P>
-All five rounding modes defined by the 2008 IEEE Floating-Point Standard are
-implemented for all operations that require rounding.
-Some ports of SoftFloat may also implement the <I>round-to-odd</I> mode.
-</P>
-
-<P>
-The rounding mode is selected by the global variable
-<BLOCKQUOTE>
-<CODE>uint_fast8_t softfloat_roundingMode;</CODE>
-</BLOCKQUOTE>
-This variable may be set to one of the values
-<BLOCKQUOTE>
-<TABLE CELLSPACING=0 CELLPADDING=0>
-<TR>
-<TD><CODE>softfloat_round_near_even</CODE></TD>
-<TD>round to nearest, with ties to even</TD>
-</TR>
-<TR>
-<TD><CODE>softfloat_round_near_maxMag&nbsp;&nbsp;</CODE></TD>
-<TD>round to nearest, with ties to maximum magnitude (away from zero)</TD>
-</TR>
-<TR>
-<TD><CODE>softfloat_round_minMag</CODE></TD>
-<TD>round to minimum magnitude (toward zero)</TD>
-</TR>
-<TR>
-<TD><CODE>softfloat_round_min</CODE></TD>
-<TD>round to minimum (down)</TD>
-</TR>
-<TR>
-<TD><CODE>softfloat_round_max</CODE></TD>
-<TD>round to maximum (up)</TD>
-</TR>
-<TR>
-<TD><CODE>softfloat_round_odd</CODE></TD>
-<TD>round to odd (jamming), if supported by the SoftFloat port</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-Variable <CODE>softfloat_roundingMode</CODE> is initialized to
-<CODE>softfloat_round_near_even</CODE>.
-</P>
-
-<P>
-When <CODE>softfloat_round_odd</CODE> is the rounding mode for a function that
-rounds to an integer value (either conversion to an integer format or a
-&lsquo;<CODE>roundToInt</CODE>&rsquo; function), if the input is not already an
-integer, the rounded result is the closest <EM>odd</EM> integer.
-For other operations, this rounding mode acts as though the floating-point
-result is first rounded to minimum magnitude, the same as
-<CODE>softfloat_round_minMag</CODE>, and then, if the result is inexact, the
-least-significant bit of the result is set <NOBR>to 1</NOBR>.
-Rounding to odd is also known as <EM>jamming</EM>.
-</P>
-
-<H3>6.2. Underflow Detection</H3>
-
-<P>
-In the terminology of the IEEE Standard, SoftFloat can detect tininess for
-underflow either before or after rounding.
-The choice is made by the global variable
-<BLOCKQUOTE>
-<CODE>uint_fast8_t softfloat_detectTininess;</CODE>
-</BLOCKQUOTE>
-which can be set to either
-<BLOCKQUOTE>
-<CODE>softfloat_tininess_beforeRounding</CODE><BR>
-<CODE>softfloat_tininess_afterRounding</CODE>
-</BLOCKQUOTE>
-Detecting tininess after rounding is usually better because it results in fewer
-spurious underflow signals.
-The other option is provided for compatibility with some systems.
-Like most systems (and as required by the newer 2008 IEEE Standard), SoftFloat
-always detects loss of accuracy for underflow as an inexact result.
-</P>
-
-<H3>6.3. Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</H3>
-
-<P>
-For <CODE>extFloat80_t</CODE> only, the rounding precision of the basic
-arithmetic operations is controlled by the global variable
-<BLOCKQUOTE>
-<CODE>uint_fast8_t extF80_roundingPrecision;</CODE>
-</BLOCKQUOTE>
-The operations affected are:
-<BLOCKQUOTE>
-<CODE>extF80_add</CODE><BR>
-<CODE>extF80_sub</CODE><BR>
-<CODE>extF80_mul</CODE><BR>
-<CODE>extF80_div</CODE><BR>
-<CODE>extF80_sqrt</CODE>
-</BLOCKQUOTE>
-When <CODE>extF80_roundingPrecision</CODE> is set to its default value of 80,
-these operations are rounded to the full precision of the <NOBR>80-bit</NOBR>
-double-extended-precision format, like occurs for other formats.
-Setting <CODE>extF80_roundingPrecision</CODE> to 32 or to 64 causes the
-operations listed to be rounded to <NOBR>32-bit</NOBR> precision (equivalent to
-<CODE>float32_t</CODE>) or to <NOBR>64-bit</NOBR> precision (equivalent to
-<CODE>float64_t</CODE>), respectively.
-When rounding to reduced precision, additional bits in the result significand
-beyond the rounding point are set to zero.
-The consequences of setting <CODE>extF80_roundingPrecision</CODE> to a value
-other than 32, 64, or 80 is not specified.
-Operations other than the ones listed above are not affected by
-<CODE>extF80_roundingPrecision</CODE>.
-</P>
-
-
-<H2>7. Exceptions and Exception Flags</H2>
-
-<P>
-All five exception flags required by the IEEE Floating-Point Standard are
-implemented.
-Each flag is stored as a separate bit in the global variable
-<BLOCKQUOTE>
-<CODE>uint_fast8_t softfloat_exceptionFlags;</CODE>
-</BLOCKQUOTE>
-The positions of the exception flag bits within this variable are determined by
-the bit masks
-<BLOCKQUOTE>
-<CODE>softfloat_flag_inexact</CODE><BR>
-<CODE>softfloat_flag_underflow</CODE><BR>
-<CODE>softfloat_flag_overflow</CODE><BR>
-<CODE>softfloat_flag_infinite</CODE><BR>
-<CODE>softfloat_flag_invalid</CODE>
-</BLOCKQUOTE>
-Variable <CODE>softfloat_exceptionFlags</CODE> is initialized to all zeros,
-meaning no exceptions.
-</P>
-
-<P>
-For some SoftFloat ports, <CODE>softfloat_exceptionFlags</CODE> may be
-<I>per-thread</I> (declared <CODE>thread_local</CODE>), meaning that different
-execution threads have their own separate instances of it.
-</P>
-
-<P>
-An individual exception flag can be cleared with the statement
-<BLOCKQUOTE>
-<CODE>softfloat_exceptionFlags &= ~softfloat_flag_&lt;<I>exception</I>&gt;;</CODE>
-</BLOCKQUOTE>
-where <CODE>&lt;<I>exception</I>&gt;</CODE> is the appropriate name.
-To raise a floating-point exception, function <CODE>softfloat_raiseFlags</CODE>
-should normally be used.
-</P>
-
-<P>
-When SoftFloat detects an exception other than <I>inexact</I>, it calls
-<CODE>softfloat_raiseFlags</CODE>.
-The default version of this function simply raises the corresponding exception
-flags.
-Particular ports of SoftFloat may support alternate behavior, such as exception
-traps, by modifying the default <CODE>softfloat_raiseFlags</CODE>.
-A program may also supply its own <CODE>softfloat_raiseFlags</CODE> function to
-override the one from the SoftFloat library.
-</P>
-
-<P>
-Because inexact results occur frequently under most circumstances (and thus are
-hardly exceptional), SoftFloat does not ordinarily call
-<CODE>softfloat_raiseFlags</CODE> for <I>inexact</I> exceptions.
-It does always raise the <I>inexact</I> exception flag as required.
-</P>
-
-
-<H2>8. Function Details</H2>
-
-<P>
-In this section, <CODE>&lt;<I>float</I>&gt;</CODE> appears in function names as
-a substitute for one of these abbreviations:
-<BLOCKQUOTE>
-<TABLE CELLSPACING=0 CELLPADDING=0>
-<TR>
-<TD><CODE>f16</CODE></TD>
-<TD>indicates <CODE>float16_t</CODE>, passed by value</TD>
-</TR>
-<TR>
-<TD><CODE>f32</CODE></TD>
-<TD>indicates <CODE>float32_t</CODE>, passed by value</TD>
-</TR>
-<TR>
-<TD><CODE>f64</CODE></TD>
-<TD>indicates <CODE>float64_t</CODE>, passed by value</TD>
-</TR>
-<TR>
-<TD><CODE>extF80M&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD>indicates <CODE>extFloat80_t</CODE>, passed indirectly via pointers</TD>
-</TR>
-<TR>
-<TD><CODE>extF80</CODE></TD>
-<TD>indicates <CODE>extFloat80_t</CODE>, passed by value</TD>
-</TR>
-<TR>
-<TD><CODE>f128M</CODE></TD>
-<TD>indicates <CODE>float128_t</CODE>, passed indirectly via pointers</TD>
-</TR>
-<TR>
-<TD><CODE>f128</CODE></TD>
-<TD>indicates <CODE>float128_t</CODE>, passed by value</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-The circumstances under which values of floating-point types
-<CODE>extFloat80_t</CODE> and <CODE>float128_t</CODE> may be passed either by
-value or indirectly via pointers was discussed earlier in
-<NOBR>section 4.5</NOBR>, <I>Conventions for Passing Arguments and Results</I>.
-</P>
-
-<H3>8.1. Conversions from Integer to Floating-Point</H3>
-
-<P>
-All conversions from a <NOBR>32-bit</NOBR> or <NOBR>64-bit</NOBR> integer,
-signed or unsigned, to a floating-point format are supported.
-Functions performing these conversions have these names:
-<BLOCKQUOTE>
-<CODE>ui32_to_&lt;<I>float</I>&gt;</CODE><BR>
-<CODE>ui64_to_&lt;<I>float</I>&gt;</CODE><BR>
-<CODE>i32_to_&lt;<I>float</I>&gt;</CODE><BR>
-<CODE>i64_to_&lt;<I>float</I>&gt;</CODE>
-</BLOCKQUOTE>
-Conversions from <NOBR>32-bit</NOBR> integers to <NOBR>64-bit</NOBR>
-double-precision and larger formats are always exact, and likewise conversions
-from <NOBR>64-bit</NOBR> integers to <NOBR>80-bit</NOBR>
-double-extended-precision and <NOBR>128-bit</NOBR> quadruple-precision are also
-always exact.
-</P>
-
-<P>
-Each conversion function takes one input of the appropriate type and generates
-one output.
-The following illustrates the signatures of these functions in cases when the
-floating-point result is passed either by value or via pointers:
-<BLOCKQUOTE>
-<PRE>
-float64_t i32_to_f64( int32_t <I>a</I> );
-</PRE>
-<PRE>
-void i32_to_f128M( int32_t <I>a</I>, float128_t *<I>destPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<H3>8.2. Conversions from Floating-Point to Integer</H3>
-
-<P>
-Conversions from a floating-point format to a <NOBR>32-bit</NOBR> or
-<NOBR>64-bit</NOBR> integer, signed or unsigned, are supported with these
-functions:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_to_ui32</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_ui64</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_i32</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_i64</CODE>
-</BLOCKQUOTE>
-The functions have signatures as follows, depending on whether the
-floating-point input is passed by value or via pointers:
-<BLOCKQUOTE>
-<PRE>
-int_fast32_t f64_to_i32( float64_t <I>a</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
-</PRE>
-<PRE>
-int_fast32_t
- f128M_to_i32( const float128_t *<I>aPtr</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-The <CODE><I>roundingMode</I></CODE> argument specifies the rounding mode for
-the conversion.
-The variable that usually indicates rounding mode,
-<CODE>softfloat_roundingMode</CODE>, is ignored.
-Argument <CODE><I>exact</I></CODE> determines whether the <I>inexact</I>
-exception flag is raised if the conversion is not exact.
-If <CODE><I>exact</I></CODE> is <CODE>true</CODE>, the <I>inexact</I> flag may
-be raised;
-otherwise, it will not be, even if the conversion is inexact.
-</P>
-
-<P>
-A conversion from floating-point to integer format raises the <I>invalid</I>
-exception if the source value cannot be rounded to a representable integer of
-the desired size (32 or 64 bits).
-In such circumstances, the integer result returned is determined by the
-particular port of SoftFloat, although typically this value will be either the
-maximum or minimum value of the integer format.
-The functions that convert to integer types never raise the floating-point
-<I>overflow</I> exception.
-</P>
-
-<P>
-Because languages such <NOBR>as C</NOBR> require that conversions to integers
-be rounded toward zero, the following functions are provided for improved speed
-and convenience:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_to_ui32_r_minMag</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_ui64_r_minMag</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_i32_r_minMag</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_to_i64_r_minMag</CODE>
-</BLOCKQUOTE>
-These functions round only toward zero (to minimum magnitude).
-The signatures for these functions are the same as above without the redundant
-<CODE><I>roundingMode</I></CODE> argument:
-<BLOCKQUOTE>
-<PRE>
-int_fast32_t f64_to_i32_r_minMag( float64_t <I>a</I>, bool <I>exact</I> );
-</PRE>
-<PRE>
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *<I>aPtr</I>, bool <I>exact</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<H3>8.3. Conversions Among Floating-Point Types</H3>
-
-<P>
-Conversions between floating-point formats are done by functions with these
-names:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_to_&lt;<I>float</I>&gt;</CODE>
-</BLOCKQUOTE>
-All combinations of source and result type are supported where the source and
-result are different formats.
-There are four different styles of signature for these functions, depending on
-whether the input and the output floating-point values are passed by value or
-via pointers:
-<BLOCKQUOTE>
-<PRE>
-float32_t f64_to_f32( float64_t <I>a</I> );
-</PRE>
-<PRE>
-float32_t f128M_to_f32( const float128_t *<I>aPtr</I> );
-</PRE>
-<PRE>
-void f32_to_f128M( float32_t <I>a</I>, float128_t *<I>destPtr</I> );
-</PRE>
-<PRE>
-void extF80M_to_f128M( const extFloat80_t *<I>aPtr</I>, float128_t *<I>destPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-Conversions from a smaller to a larger floating-point format are always exact
-and so require no rounding.
-</P>
-
-<H3>8.4. Basic Arithmetic Functions</H3>
-
-<P>
-The following basic arithmetic functions are provided:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_add</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_sub</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_mul</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_div</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_sqrt</CODE>
-</BLOCKQUOTE>
-Each floating-point operation takes two operands, except for <CODE>sqrt</CODE>
-(square root) which takes only one.
-The operands and result are all of the same floating-point format.
-Signatures for these functions take the following forms:
-<BLOCKQUOTE>
-<PRE>
-float64_t f64_add( float64_t <I>a</I>, float64_t <I>b</I> );
-</PRE>
-<PRE>
-void
- f128M_add(
-     const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I>, float128_t *<I>destPtr</I> );
-</PRE>
-<PRE>
-float64_t f64_sqrt( float64_t <I>a</I> );
-</PRE>
-<PRE>
-void f128M_sqrt( const float128_t *<I>aPtr</I>, float128_t *<I>destPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-When floating-point values are passed indirectly through pointers, arguments
-<CODE><I>aPtr</I></CODE> and <CODE><I>bPtr</I></CODE> point to the input
-operands, and the last argument, <CODE><I>destPtr</I></CODE>, points to the
-location where the result is stored.
-</P>
-
-<P>
-Rounding of the <NOBR>80-bit</NOBR> double-extended-precision
-(<CODE>extFloat80_t</CODE>) functions is affected by variable
-<CODE>extF80_roundingPrecision</CODE>, as explained earlier in
-<NOBR>section 6.3</NOBR>,
-<I>Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</I>.
-</P>
-
-<H3>8.5. Fused Multiply-Add Functions</H3>
-
-<P>
-The 2008 version of the IEEE Floating-Point Standard defines a <I>fused
-multiply-add</I> operation that does a combined multiplication and addition
-with only a single rounding.
-SoftFloat implements fused multiply-add with functions
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_mulAdd</CODE>
-</BLOCKQUOTE>
-Unlike other operations, fused multiple-add is not supported for the
-<NOBR>80-bit</NOBR> double-extended-precision format,
-<CODE>extFloat80_t</CODE>.
-</P>
-
-<P>
-Depending on whether floating-point values are passed by value or via pointers,
-the fused multiply-add functions have signatures of these forms:
-<BLOCKQUOTE>
-<PRE>
-float64_t f64_mulAdd( float64_t <I>a</I>, float64_t <I>b</I>, float64_t <I>c</I> );
-</PRE>
-<PRE>
-void
- f128M_mulAdd(
-     const float128_t *<I>aPtr</I>,
-     const float128_t *<I>bPtr</I>,
-     const float128_t *<I>cPtr</I>,
-     float128_t *<I>destPtr</I>
- );
-</PRE>
-</BLOCKQUOTE>
-The functions compute
-<NOBR>(<CODE><I>a</I></CODE> &times; <CODE><I>b</I></CODE>)
- + <CODE><I>c</I></CODE></NOBR>
-with a single rounding.
-When floating-point values are passed indirectly through pointers, arguments
-<CODE><I>aPtr</I></CODE>, <CODE><I>bPtr</I></CODE>, and
-<CODE><I>cPtr</I></CODE> point to operands <CODE><I>a</I></CODE>,
-<CODE><I>b</I></CODE>, and <CODE><I>c</I></CODE> respectively, and
-<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
-</P>
-
-<P>
-If one of the multiplication operands <CODE><I>a</I></CODE> and
-<CODE><I>b</I></CODE> is infinite and the other is zero, these functions raise
-the invalid exception even if operand <CODE><I>c</I></CODE> is a quiet NaN.
-</P>
-
-<H3>8.6. Remainder Functions</H3>
-
-<P>
-For each format, SoftFloat implements the remainder operation defined by the
-IEEE Floating-Point Standard.
-The remainder functions have names
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_rem</CODE>
-</BLOCKQUOTE>
-Each remainder operation takes two floating-point operands of the same format
-and returns a result in the same format.
-Depending on whether floating-point values are passed by value or via pointers,
-the remainder functions have signatures of these forms:
-<BLOCKQUOTE>
-<PRE>
-float64_t f64_rem( float64_t <I>a</I>, float64_t <I>b</I> );
-</PRE>
-<PRE>
-void
- f128M_rem(
-     const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I>, float128_t *<I>destPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-When floating-point values are passed indirectly through pointers, arguments
-<CODE><I>aPtr</I></CODE> and <CODE><I>bPtr</I></CODE> point to operands
-<CODE><I>a</I></CODE> and <CODE><I>b</I></CODE> respectively, and
-<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
-</P>
-
-<P>
-The IEEE Standard remainder operation computes the value
-<NOBR><CODE><I>a</I></CODE>
- &minus; <I>n</I> &times; <CODE><I>b</I></CODE></NOBR>,
-where <I>n</I> is the integer closest to
-<NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR>.
-If <NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR> is exactly
-halfway between two integers, <I>n</I> is the <EM>even</EM> integer closest to
-<NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR>.
-The IEEE Standard&rsquo;s remainder operation is always exact and so requires
-no rounding.
-</P>
-
-<P>
-Depending on the relative magnitudes of the operands, the remainder
-functions can take considerably longer to execute than the other SoftFloat
-functions.
-This is an inherent characteristic of the remainder operation itself and is not
-a flaw in the SoftFloat implementation.
-</P>
-
-<H3>8.7. Round-to-Integer Functions</H3>
-
-<P>
-For each format, SoftFloat implements the round-to-integer operation specified
-by the IEEE Floating-Point Standard.
-These functions are named
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_roundToInt</CODE>
-</BLOCKQUOTE>
-Each round-to-integer operation takes a single floating-point operand.
-This operand is rounded to an integer according to a specified rounding mode,
-and the resulting integer value is returned in the same floating-point format.
-(Note that the result is not an integer type.)
-</P>
-
-<P>
-The signatures of the round-to-integer functions are similar to those for
-conversions to an integer type:
-<BLOCKQUOTE>
-<PRE>
-float64_t f64_roundToInt( float64_t <I>a</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
-</PRE>
-<PRE>
-void
- f128M_roundToInt(
-     const float128_t *<I>aPtr</I>,
-     uint_fast8_t <I>roundingMode</I>,
-     bool <I>exact</I>,
-     float128_t *<I>destPtr</I>
- );
-</PRE>
-</BLOCKQUOTE>
-When floating-point values are passed indirectly through pointers,
-<CODE><I>aPtr</I></CODE> points to the input operand and
-<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
-</P>
-
-<P>
-The <CODE><I>roundingMode</I></CODE> argument specifies the rounding mode to
-apply.
-The variable that usually indicates rounding mode,
-<CODE>softfloat_roundingMode</CODE>, is ignored.
-Argument <CODE><I>exact</I></CODE> determines whether the <I>inexact</I>
-exception flag is raised if the conversion is not exact.
-If <CODE><I>exact</I></CODE> is <CODE>true</CODE>, the <I>inexact</I> flag may
-be raised;
-otherwise, it will not be, even if the conversion is inexact.
-</P>
-
-<H3>8.8. Comparison Functions</H3>
-
-<P>
-For each format, the following floating-point comparison functions are
-provided:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_eq</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_le</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_lt</CODE>
-</BLOCKQUOTE>
-Each comparison takes two operands of the same type and returns a Boolean.
-The abbreviation <CODE>eq</CODE> stands for &ldquo;equal&rdquo; (=);
-<CODE>le</CODE> stands for &ldquo;less than or equal&rdquo; (&le;);
-and <CODE>lt</CODE> stands for &ldquo;less than&rdquo; (&lt;).
-Depending on whether the floating-point operands are passed by value or via
-pointers, the comparison functions have signatures of these forms:
-<BLOCKQUOTE>
-<PRE>
-bool f64_eq( float64_t <I>a</I>, float64_t <I>b</I> );
-</PRE>
-<PRE>
-bool f128M_eq( const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-The usual greater-than (&gt;), greater-than-or-equal (&ge;), and not-equal
-(&ne;) comparisons are easily obtained from the functions provided.
-The not-equal function is just the logical complement of the equal function.
-The greater-than-or-equal function is identical to the less-than-or-equal
-function with the arguments in reverse order, and likewise the greater-than
-function is identical to the less-than function with the arguments reversed.
-</P>
-
-<P>
-The IEEE Floating-Point Standard specifies that the less-than-or-equal and
-less-than comparisons by default raise the <I>invalid</I> exception if either
-operand is any kind of NaN.
-Equality comparisons, on the other hand, are defined by default to raise the
-<I>invalid</I> exception only for signaling NaNs, not quiet NaNs.
-For completeness, SoftFloat provides these complementary functions:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_eq_signaling</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_le_quiet</CODE><BR>
-<CODE>&lt;<I>float</I>&gt;_lt_quiet</CODE>
-</BLOCKQUOTE>
-The <CODE>signaling</CODE> equality comparisons are identical to the default
-equality comparisons except that the <I>invalid</I> exception is raised for any
-NaN input, not just for signaling NaNs.
-Similarly, the <CODE>quiet</CODE> comparison functions are identical to their
-default counterparts except that the <I>invalid</I> exception is not raised for
-quiet NaNs.
-</P>
-
-<H3>8.9. Signaling NaN Test Functions</H3>
-
-<P>
-Functions for testing whether a floating-point value is a signaling NaN are
-provided with these names:
-<BLOCKQUOTE>
-<CODE>&lt;<I>float</I>&gt;_isSignalingNaN</CODE>
-</BLOCKQUOTE>
-The functions take one floating-point operand and return a Boolean indicating
-whether the operand is a signaling NaN.
-Accordingly, the functions have the forms
-<BLOCKQUOTE>
-<PRE>
-bool f64_isSignalingNaN( float64_t <I>a</I> );
-</PRE>
-<PRE>
-bool f128M_isSignalingNaN( const float128_t *<I>aPtr</I> );
-</PRE>
-</BLOCKQUOTE>
-</P>
-
-<H3>8.10. Raise-Exception Function</H3>
-
-<P>
-SoftFloat provides a single function for raising floating-point exceptions:
-<BLOCKQUOTE>
-<PRE>
-void softfloat_raiseFlags( uint_fast8_t <I>exceptions</I> );
-</PRE>
-</BLOCKQUOTE>
-The <CODE><I>exceptions</I></CODE> argument is a mask indicating the set of
-exceptions to raise.
-(See earlier section 7, <I>Exceptions and Exception Flags</I>.)
-In addition to setting the specified exception flags in variable
-<CODE>softfloat_exceptionFlags</CODE>, the <CODE>softfloat_raiseFlags</CODE>
-function may cause a trap or abort appropriate for the current system.
-</P>
-
-
-<H2>9. Changes from SoftFloat <NOBR>Release 2</NOBR></H2>
-
-<P>
-Apart from a change in the legal use license, <NOBR>Release 3</NOBR> of
-SoftFloat introduced numerous technical differences compared to earlier
-releases.
-</P>
-
-<H3>9.1. Name Changes</H3>
-
-<P>
-The most obvious and pervasive difference compared to <NOBR>Release 2</NOBR>
-is that the names of most functions and variables have changed, even when the
-behavior has not.
-First, the floating-point types, the mode variables, the exception flags
-variable, the function to raise exceptions, and various associated constants
-have been renamed as follows:
-<BLOCKQUOTE>
-<TABLE>
-<TR>
-<TD>old name, Release 2:</TD>
-<TD>new name, Release 3:</TD>
-</TR>
-<TR>
-<TD><CODE>float32</CODE></TD>
-<TD><CODE>float32_t</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float64</CODE></TD>
-<TD><CODE>float64_t</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>floatx80</CODE></TD>
-<TD><CODE>extFloat80_t</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float128</CODE></TD>
-<TD><CODE>float128_t</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_rounding_mode</CODE></TD>
-<TD><CODE>softfloat_roundingMode</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_round_nearest_even</CODE></TD>
-<TD><CODE>softfloat_round_near_even</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_round_to_zero</CODE></TD>
-<TD><CODE>softfloat_round_minMag</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_round_down</CODE></TD>
-<TD><CODE>softfloat_round_min</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_round_up</CODE></TD>
-<TD><CODE>softfloat_round_max</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_detect_tininess</CODE></TD>
-<TD><CODE>softfloat_detectTininess</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_tininess_before_rounding&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD><CODE>softfloat_tininess_beforeRounding</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_tininess_after_rounding</CODE></TD>
-<TD><CODE>softfloat_tininess_afterRounding</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>floatx80_rounding_precision</CODE></TD>
-<TD><CODE>extF80_roundingPrecision</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_exception_flags</CODE></TD>
-<TD><CODE>softfloat_exceptionFlags</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_flag_inexact</CODE></TD>
-<TD><CODE>softfloat_flag_inexact</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_flag_underflow</CODE></TD>
-<TD><CODE>softfloat_flag_underflow</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_flag_overflow</CODE></TD>
-<TD><CODE>softfloat_flag_overflow</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_flag_divbyzero</CODE></TD>
-<TD><CODE>softfloat_flag_infinite</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_flag_invalid</CODE></TD>
-<TD><CODE>softfloat_flag_invalid</CODE></TD>
-</TR>
-<TR>
-<TD><CODE>float_raise</CODE></TD>
-<TD><CODE>softfloat_raiseFlags</CODE></TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-</P>
-
-<P>
-Furthermore, <NOBR>Release 3</NOBR> adopted the following new abbreviations for
-function names:
-<BLOCKQUOTE>
-<TABLE>
-<TR>
-<TD>used in names in Release 2:<CODE>&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD>used in names in Release 3:</TD>
-</TR>
-<TR> <TD><CODE>int32</CODE></TD>    <TD><CODE>i32</CODE></TD>    </TR>
-<TR> <TD><CODE>int64</CODE></TD>    <TD><CODE>i64</CODE></TD>    </TR>
-<TR> <TD><CODE>float32</CODE></TD>  <TD><CODE>f32</CODE></TD>    </TR>
-<TR> <TD><CODE>float64</CODE></TD>  <TD><CODE>f64</CODE></TD>    </TR>
-<TR> <TD><CODE>floatx80</CODE></TD> <TD><CODE>extF80</CODE></TD> </TR>
-<TR> <TD><CODE>float128</CODE></TD> <TD><CODE>f128</CODE></TD>   </TR>
-</TABLE>
-</BLOCKQUOTE>
-Thus, for example, the function to add two <NOBR>32-bit</NOBR> floating-point
-numbers, previously called <CODE>float32_add</CODE> in <NOBR>Release 2</NOBR>,
-is now <CODE>f32_add</CODE>.
-Lastly, there have been a few other changes to function names:
-<BLOCKQUOTE>
-<TABLE>
-<TR>
-<TD>used in names in Release 2:<CODE>&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD>used in names in Release 3:<CODE>&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD>relevant functions:</TD>
-</TR>
-<TR>
-<TD><CODE>_round_to_zero</CODE></TD>
-<TD><CODE>_r_minMag</CODE></TD>
-<TD>conversions from floating-point to integer (<NOBR>section 8.2</NOBR>)</TD>
-</TR>
-<TR>
-<TD><CODE>round_to_int</CODE></TD>
-<TD><CODE>roundToInt</CODE></TD>
-<TD>round-to-integer functions (<NOBR>section 8.7</NOBR>)</TD>
-</TR>
-<TR>
-<TD><CODE>is_signaling_nan&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
-<TD><CODE>isSignalingNaN</CODE></TD>
-<TD>signaling NaN test functions (<NOBR>section 8.9</NOBR>)</TD>
-</TR>
-</TABLE>
-</BLOCKQUOTE>
-</P>
-
-<H3>9.2. Changes to Function Arguments</H3>
-
-<P>
-Besides simple name changes, some operations were given a different interface
-in <NOBR>Release 3</NOBR> than they had in <NOBR>Release 2</NOBR>:
-<UL>
-
-<LI>
-<P>
-Since <NOBR>Release 3</NOBR>, integer arguments and results of functions have
-standard types from header <CODE>&lt;stdint.h&gt;</CODE>, such as
-<CODE>uint32_t</CODE>, whereas previously their types could be defined
-differently for each port of SoftFloat, usually using traditional C types such
-as <CODE>unsigned</CODE> <CODE>int</CODE>.
-Likewise, functions in <NOBR>Release 3</NOBR> and later pass Booleans as
-standard type <CODE>bool</CODE> from <CODE>&lt;stdbool.h&gt;</CODE>, whereas
-previously these were again passed as a port-specific type (usually
-<CODE>int</CODE>).
-</P>
-
-<LI>
-<P>
-As explained earlier in <NOBR>section 4.5</NOBR>, <I>Conventions for Passing
-Arguments and Results</I>, SoftFloat functions in <NOBR>Release 3</NOBR> and
-later may pass <NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> floating-point
-values through pointers, meaning that functions take pointer arguments and then
-read or write floating-point values at the locations indicated by the pointers.
-In <NOBR>Release 2</NOBR>, floating-point arguments and results were always
-passed by value, regardless of their size.
-</P>
-
-<LI>
-<P>
-Functions that round to an integer have additional
-<CODE><I>roundingMode</I></CODE> and <CODE><I>exact</I></CODE> arguments that
-they did not have in <NOBR>Release 2</NOBR>.
-Refer to sections 8.2 <NOBR>and 8.7</NOBR> for descriptions of these functions
-since <NOBR>Release 3</NOBR>.
-For <NOBR>Release 2</NOBR>, the rounding mode, when needed, was taken from the
-same global variable that affects the basic arithmetic operations (now called
-<CODE>softfloat_roundingMode</CODE> but previously known as
-<CODE>float_rounding_mode</CODE>).
-Also, for <NOBR>Release 2</NOBR>, if the original floating-point input was not
-an exact integer value, and if the <I>invalid</I> exception was not raised by
-the function, the <I>inexact</I> exception was always raised.
-<NOBR>Release 2</NOBR> had no option to suppress raising <I>inexact</I> in this
-case.
-Applications using SoftFloat <NOBR>Release 3</NOBR> or later can get the same
-effect as <NOBR>Release 2</NOBR> by passing variable
-<CODE>softfloat_roundingMode</CODE> for argument
-<CODE><I>roundingMode</I></CODE> and <CODE>true</CODE> for argument
-<CODE><I>exact</I></CODE>.
-</P>
-
-</UL>
-</P>
-
-<H3>9.3. Added Capabilities</H3>
-
-<P>
-With <NOBR>Release 3</NOBR>, some new features have been added that were not
-present in <NOBR>Release 2</NOBR>:
-<UL>
-
-<LI>
-<P>
-A port of SoftFloat can now define any of the floating-point types
-<CODE>float32_t</CODE>, <CODE>float64_t</CODE>, <CODE>extFloat80_t</CODE>, and
-<CODE>float128_t</CODE> as aliases for C&rsquo;s standard floating-point types
-<CODE>float</CODE>, <CODE>double</CODE>, and <CODE>long</CODE>
-<CODE>double</CODE>, using either <CODE>#define</CODE> or <CODE>typedef</CODE>.
-This potential convenience was not supported under <NOBR>Release 2</NOBR>.
-</P>
-
-<P>
-(Note, however, that there may be a performance cost to defining
-SoftFloat&rsquo;s floating-point types this way, depending on the platform and
-the applications using SoftFloat.
-Ports of SoftFloat may choose to forgo the convenience in favor of better
-speed.)
-</P>
-
-<P>
-<LI>
-As of <NOBR>Release 3b</NOBR>, <NOBR>16-bit</NOBR> half-precision,
-<CODE>float16_t</CODE>, is supported.
-</P>
-
-<P>
-<LI>
-Functions have been added for converting between the floating-point types and
-unsigned integers.
-<NOBR>Release 2</NOBR> supported only signed integers, not unsigned.
-</P>
-
-<P>
-<LI>
-Fused multiply-add functions have been added for all floating-point formats
-except <NOBR>80-bit</NOBR> double-extended-precision,
-<CODE>extFloat80_t</CODE>.
-</P>
-
-<P>
-<LI>
-New rounding modes are supported:
-<CODE>softfloat_round_near_maxMag</CODE> (round to nearest, with ties to
-maximum magnitude, away from zero), and, as of <NOBR>Release 3c</NOBR>,
-optional <CODE>softfloat_round_odd</CODE> (round to odd, also known as
-jamming).
-</P>
-
-</UL>
-</P>
-
-<H3>9.4. Better Compatibility with the C Language</H3>
-
-<P>
-<NOBR>Release 3</NOBR> of SoftFloat was written to conform better to the ISO C
-Standard&rsquo;s rules for portability.
-For example, older releases of SoftFloat employed type conversions in ways
-that, while commonly practiced, are not fully defined by the C Standard.
-Such problematic type conversions have generally been replaced by the use of
-unions, the behavior around which is more strictly regulated these days.
-</P>
-
-<H3>9.5. New Organization as a Library</H3>
-
-<P>
-Starting with <NOBR>Release 3</NOBR>, SoftFloat now builds as a library.
-Previously, SoftFloat compiled into a single, monolithic object file containing
-all the SoftFloat functions, with the consequence that a program linking with
-SoftFloat would get every SoftFloat function in its binary file even if only a
-few functions were actually used.
-With SoftFloat in the form of a library, a program that is linked by a standard
-linker will include only those functions of SoftFloat that it needs and no
-others.
-</P>
-
-<H3>9.6. Optimization Gains (and Losses)</H3>
-
-<P>
-Individual SoftFloat functions have been variously improved in
-<NOBR>Release 3</NOBR> compared to earlier releases.
-In particular, better, faster algorithms have been deployed for the operations
-of division, square root, and remainder.
-For functions operating on the larger <NOBR>80-bit</NOBR> and
-<NOBR>128-bit</NOBR> formats, <CODE>extFloat80_t</CODE> and
-<CODE>float128_t</CODE>, code size has also generally been reduced.
-</P>
-
-<P>
-However, because <NOBR>Release 2</NOBR> compiled all of SoftFloat together as a
-single object file, compilers could make optimizations across function calls
-when one SoftFloat function calls another.
-Now that the functions of SoftFloat are compiled separately and only afterward
-linked together into a program, there is not usually the same opportunity to
-optimize across function calls.
-Some loss of speed has been observed due to this change.
-</P>
-
-
-<H2>10. Future Directions</H2>
-
-<P>
-The following improvements are anticipated for future releases of SoftFloat:
-<UL>
-<LI>
-more functions from the 2008 version of the IEEE Floating-Point Standard;
-<LI>
-consistent, defined behavior for non-canonical representations of extended
-format <CODE>extFloat80_t</CODE> (discussed in <NOBR>section 4.4</NOBR>,
-<I>Non-canonical Representations in <CODE>extFloat80_t</CODE></I>).
-
-</UL>
-</P>
-
-
-<H2>11. Contact Information</H2>
-
-<P>
-At the time of this writing, the most up-to-date information about SoftFloat
-and the latest release can be found at the Web page
-<A HREF="http://www.jhauser.us/arithmetic/SoftFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/SoftFloat.html</CODE></NOBR></A>.
-</P>
-
-
-</BODY>
-
+
+<HTML>
+
+<HEAD>
+<TITLE>Berkeley SoftFloat Library Interface</TITLE>
+</HEAD>
+
+<BODY>
+
+<H1>Berkeley SoftFloat Release 3e: Library Interface</H1>
+
+<P>
+John R. Hauser<BR>
+2018 January 20<BR>
+</P>
+
+
+<H2>Contents</H2>
+
+<BLOCKQUOTE>
+<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0>
+<COL WIDTH=25>
+<COL WIDTH=*>
+<TR><TD COLSPAN=2>1. Introduction</TD></TR>
+<TR><TD COLSPAN=2>2. Limitations</TD></TR>
+<TR><TD COLSPAN=2>3. Acknowledgments and License</TD></TR>
+<TR><TD COLSPAN=2>4. Types and Functions</TD></TR>
+<TR><TD></TD><TD>4.1. Boolean and Integer Types</TD></TR>
+<TR><TD></TD><TD>4.2. Floating-Point Types</TD></TR>
+<TR><TD></TD><TD>4.3. Supported Floating-Point Functions</TD></TR>
+<TR>
+  <TD></TD>
+  <TD>4.4. Non-canonical Representations in <CODE>extFloat80_t</CODE></TD>
+</TR>
+<TR><TD></TD><TD>4.5. Conventions for Passing Arguments and Results</TD></TR>
+<TR><TD COLSPAN=2>5. Reserved Names</TD></TR>
+<TR><TD COLSPAN=2>6. Mode Variables</TD></TR>
+<TR><TD></TD><TD>6.1. Rounding Mode</TD></TR>
+<TR><TD></TD><TD>6.2. Underflow Detection</TD></TR>
+<TR>
+  <TD></TD>
+  <TD>6.3. Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</TD>
+</TR>
+<TR><TD COLSPAN=2>7. Exceptions and Exception Flags</TD></TR>
+<TR><TD COLSPAN=2>8. Function Details</TD></TR>
+<TR><TD></TD><TD>8.1. Conversions from Integer to Floating-Point</TD></TR>
+<TR><TD></TD><TD>8.2. Conversions from Floating-Point to Integer</TD></TR>
+<TR><TD></TD><TD>8.3. Conversions Among Floating-Point Types</TD></TR>
+<TR><TD></TD><TD>8.4. Basic Arithmetic Functions</TD></TR>
+<TR><TD></TD><TD>8.5. Fused Multiply-Add Functions</TD></TR>
+<TR><TD></TD><TD>8.6. Remainder Functions</TD></TR>
+<TR><TD></TD><TD>8.7. Round-to-Integer Functions</TD></TR>
+<TR><TD></TD><TD>8.8. Comparison Functions</TD></TR>
+<TR><TD></TD><TD>8.9. Signaling NaN Test Functions</TD></TR>
+<TR><TD></TD><TD>8.10. Raise-Exception Function</TD></TR>
+<TR><TD COLSPAN=2>9. Changes from SoftFloat <NOBR>Release 2</NOBR></TD></TR>
+<TR><TD></TD><TD>9.1. Name Changes</TD></TR>
+<TR><TD></TD><TD>9.2. Changes to Function Arguments</TD></TR>
+<TR><TD></TD><TD>9.3. Added Capabilities</TD></TR>
+<TR><TD></TD><TD>9.4. Better Compatibility with the C Language</TD></TR>
+<TR><TD></TD><TD>9.5. New Organization as a Library</TD></TR>
+<TR><TD></TD><TD>9.6. Optimization Gains (and Losses)</TD></TR>
+<TR><TD COLSPAN=2>10. Future Directions</TD></TR>
+<TR><TD COLSPAN=2>11. Contact Information</TD></TR>
+</TABLE>
+</BLOCKQUOTE>
+
+
+<H2>1. Introduction</H2>
+
+<P>
+Berkeley SoftFloat is a software implementation of binary floating-point that
+conforms to the IEEE Standard for Floating-Point Arithmetic.
+The current release supports five binary formats:  <NOBR>16-bit</NOBR>
+half-precision, <NOBR>32-bit</NOBR> single-precision, <NOBR>64-bit</NOBR>
+double-precision, <NOBR>80-bit</NOBR> double-extended-precision, and
+<NOBR>128-bit</NOBR> quadruple-precision.
+The following functions are supported for each format:
+<UL>
+<LI>
+addition, subtraction, multiplication, division, and square root;
+<LI>
+fused multiply-add as defined by the IEEE Standard, except for
+<NOBR>80-bit</NOBR> double-extended-precision;
+<LI>
+remainder as defined by the IEEE Standard;
+<LI>
+round to integral value;
+<LI>
+comparisons;
+<LI>
+conversions to/from other supported formats; and
+<LI>
+conversions to/from <NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> integers,
+signed and unsigned.
+</UL>
+All operations required by the original 1985 version of the IEEE Floating-Point
+Standard are implemented, except for conversions to and from decimal.
+</P>
+
+<P>
+This document gives information about the types defined and the routines
+implemented by SoftFloat.
+It does not attempt to define or explain the IEEE Floating-Point Standard.
+Information about the standard is available elsewhere.
+</P>
+
+<P>
+The current version of SoftFloat is <NOBR>Release 3e</NOBR>.
+This release modifies the behavior of the rarely used <I>odd</I> rounding mode
+(<I>round to odd</I>, also known as <I>jamming</I>), and also adds some new
+specialization and optimization examples for those compiling SoftFloat.
+</P>
+
+<P>
+The previous <NOBR>Release 3d</NOBR> fixed bugs that were found in the square
+root functions for the <NOBR>64-bit</NOBR>, <NOBR>80-bit</NOBR>, and
+<NOBR>128-bit</NOBR> floating-point formats.
+(Thanks to Alexei Sibidanov at the University of Victoria for reporting an
+incorrect result.)
+The bugs affected all prior <NOBR>Release-3</NOBR> versions of SoftFloat
+<NOBR>through 3c</NOBR>.
+The flaw in the <NOBR>64-bit</NOBR> floating-point square root function was of
+very minor impact, causing a <NOBR>1-ulp</NOBR> error (<NOBR>1 unit</NOBR> in
+the last place) a few times out of a billion.
+The bugs in the <NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> square root
+functions were more serious.
+Although incorrect results again occurred only a few times out of a billion,
+when they did occur a large portion of the less-significant bits could be
+wrong.
+</P>
+
+<P>
+Among earlier releases, 3b was notable for adding support for the
+<NOBR>16-bit</NOBR> half-precision format.
+For more about the evolution of SoftFloat releases, see
+<A HREF="SoftFloat-history.html"><NOBR><CODE>SoftFloat-history.html</CODE></NOBR></A>.
+</P>
+
+<P>
+The functional interface of SoftFloat <NOBR>Release 3</NOBR> and later differs
+in many details from the releases that came before.
+For specifics of these differences, see <NOBR>section 9</NOBR> below,
+<I>Changes from SoftFloat <NOBR>Release 2</NOBR></I>.
+</P>
+
+
+<H2>2. Limitations</H2>
+
+<P>
+SoftFloat assumes the computer has an addressable byte size of 8 or
+<NOBR>16 bits</NOBR>.
+(Nearly all computers in use today have <NOBR>8-bit</NOBR> bytes.)
+</P>
+
+<P>
+SoftFloat is written in C and is designed to work with other C code.
+The C compiler used must conform at a minimum to the 1989 ANSI standard for the
+C language (same as the 1990 ISO standard) and must in addition support basic
+arithmetic on <NOBR>64-bit</NOBR> integers.
+Earlier releases of SoftFloat included implementations of <NOBR>32-bit</NOBR>
+single-precision and <NOBR>64-bit</NOBR> double-precision floating-point that
+did not require <NOBR>64-bit</NOBR> integers, but this option is not supported
+starting with <NOBR>Release 3</NOBR>.
+Since 1999, ISO standards for C have mandated compiler support for
+<NOBR>64-bit</NOBR> integers.
+A compiler conforming to the 1999 C Standard or later is recommended but not
+strictly required.
+</P>
+
+<P>
+Most operations not required by the original 1985 version of the IEEE
+Floating-Point Standard but added in the 2008 version are not yet supported in
+SoftFloat <NOBR>Release 3e</NOBR>.
+</P>
+
+
+<H2>3. Acknowledgments and License</H2>
+
+<P>
+The SoftFloat package was written by me, <NOBR>John R.</NOBR> Hauser.
+<NOBR>Release 3</NOBR> of SoftFloat was a completely new implementation
+supplanting earlier releases.
+The project to create <NOBR>Release 3</NOBR> (now <NOBR>through 3e</NOBR>) was
+done in the employ of the University of California, Berkeley, within the
+Department of Electrical Engineering and Computer Sciences, first for the
+Parallel Computing Laboratory (Par Lab) and then for the ASPIRE Lab.
+The work was officially overseen by Prof. Krste Asanovic, with funding provided
+by these sources:
+<BLOCKQUOTE>
+<TABLE>
+<COL>
+<COL WIDTH=10>
+<COL>
+<TR>
+<TD VALIGN=TOP><NOBR>Par Lab:</NOBR></TD>
+<TD></TD>
+<TD>
+Microsoft (Award #024263), Intel (Award #024894), and U.C. Discovery
+(Award #DIG07-10227), with additional support from Par Lab affiliates Nokia,
+NVIDIA, Oracle, and Samsung.
+</TD>
+</TR>
+<TR>
+<TD VALIGN=TOP><NOBR>ASPIRE Lab:</NOBR></TD>
+<TD></TD>
+<TD>
+DARPA PERFECT program (Award #HR0011-12-2-0016), with additional support from
+ASPIRE industrial sponsor Intel and ASPIRE affiliates Google, Nokia, NVIDIA,
+Oracle, and Samsung.
+</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+The following applies to the whole of SoftFloat <NOBR>Release 3e</NOBR> as well
+as to each source file individually.
+</P>
+
+<P>
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.
+All rights reserved.
+</P>
+
+<P>
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+<OL>
+
+<LI>
+<P>
+Redistributions of source code must retain the above copyright notice, this
+list of conditions, and the following disclaimer.
+</P>
+
+<LI>
+<P>
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions, and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+</P>
+
+<LI>
+<P>
+Neither the name of the University nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+</P>
+
+</OL>
+</P>
+
+<P>
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS &ldquo;AS IS&rdquo;,
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.
+IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+</P>
+
+
+<H2>4. Types and Functions</H2>
+
+<P>
+The types and functions of SoftFloat are declared in header file
+<CODE>softfloat.h</CODE>.
+</P>
+
+<H3>4.1. Boolean and Integer Types</H3>
+
+<P>
+Header file <CODE>softfloat.h</CODE> depends on standard headers
+<CODE>&lt;stdbool.h&gt;</CODE> and <CODE>&lt;stdint.h&gt;</CODE> to define type
+<CODE>bool</CODE> and several integer types.
+These standard headers have been part of the ISO C Standard Library since 1999.
+With any recent compiler, they are likely to be supported, even if the compiler
+does not claim complete conformance to the latest ISO C Standard.
+For older or nonstandard compilers, a port of SoftFloat may have substitutes
+for these headers.
+Header <CODE>softfloat.h</CODE> depends only on the name <CODE>bool</CODE> from
+<CODE>&lt;stdbool.h&gt;</CODE> and on these type names from
+<CODE>&lt;stdint.h&gt;</CODE>:
+<BLOCKQUOTE>
+<PRE>
+uint16_t
+uint32_t
+uint64_t
+int32_t
+int64_t
+uint_fast8_t
+uint_fast32_t
+uint_fast64_t
+int_fast32_t
+int_fast64_t
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+
+<H3>4.2. Floating-Point Types</H3>
+
+<P>
+The <CODE>softfloat.h</CODE> header defines five floating-point types:
+<BLOCKQUOTE>
+<TABLE CELLSPACING=0 CELLPADDING=0>
+<TR>
+<TD><CODE>float16_t</CODE></TD>
+<TD><NOBR>16-bit</NOBR> half-precision binary format</TD>
+</TR>
+<TR>
+<TD><CODE>float32_t</CODE></TD>
+<TD><NOBR>32-bit</NOBR> single-precision binary format</TD>
+</TR>
+<TR>
+<TD><CODE>float64_t</CODE></TD>
+<TD><NOBR>64-bit</NOBR> double-precision binary format</TD>
+</TR>
+<TR>
+<TD><CODE>extFloat80_t&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD><NOBR>80-bit</NOBR> double-extended-precision binary format (old Intel or
+Motorola format)</TD>
+</TR>
+<TR>
+<TD><CODE>float128_t</CODE></TD>
+<TD><NOBR>128-bit</NOBR> quadruple-precision binary format</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+The non-extended types are each exactly the size specified:
+<NOBR>16 bits</NOBR> for <CODE>float16_t</CODE>, <NOBR>32 bits</NOBR> for
+<CODE>float32_t</CODE>, <NOBR>64 bits</NOBR> for <CODE>float64_t</CODE>, and
+<NOBR>128 bits</NOBR> for <CODE>float128_t</CODE>.
+Aside from these size requirements, the definitions of all these types may
+differ for different ports of SoftFloat to specific systems.
+A given port of SoftFloat may or may not define some of the floating-point
+types as aliases for the C standard types <CODE>float</CODE>,
+<CODE>double</CODE>, and <CODE>long</CODE> <CODE>double</CODE>.
+</P>
+
+<P>
+Header file <CODE>softfloat.h</CODE> also defines a structure,
+<CODE>struct</CODE> <CODE>extFloat80M</CODE>, for the representation of
+<NOBR>80-bit</NOBR> double-extended-precision floating-point values in memory.
+This structure is the same size as type <CODE>extFloat80_t</CODE> and contains
+at least these two fields (not necessarily in this order):
+<BLOCKQUOTE>
+<PRE>
+uint16_t signExp;
+uint64_t signif;
+</PRE>
+</BLOCKQUOTE>
+Field <CODE>signExp</CODE> contains the sign and exponent of the floating-point
+value, with the sign in the most significant bit (<NOBR>bit 15</NOBR>) and the
+encoded exponent in the other <NOBR>15 bits</NOBR>.
+Field <CODE>signif</CODE> is the complete <NOBR>64-bit</NOBR> significand of
+the floating-point value.
+(In the usual encoding for <NOBR>80-bit</NOBR> extended floating-point, the
+leading <NOBR>1 bit</NOBR> of normalized numbers is not implicit but is stored
+in the most significant bit of the significand.)
+</P>
+
+<H3>4.3. Supported Floating-Point Functions</H3>
+
+<P>
+SoftFloat implements these arithmetic operations for its floating-point types:
+<UL>
+<LI>
+conversions between any two floating-point formats;
+<LI>
+for each floating-point format, conversions to and from signed and unsigned
+<NOBR>32-bit</NOBR> and <NOBR>64-bit</NOBR> integers;
+<LI>
+for each format, the usual addition, subtraction, multiplication, division, and
+square root operations;
+<LI>
+for each format except <CODE>extFloat80_t</CODE>, the fused multiply-add
+operation defined by the IEEE Standard;
+<LI>
+for each format, the floating-point remainder operation defined by the IEEE
+Standard;
+<LI>
+for each format, a &ldquo;round to integer&rdquo; operation that rounds to the
+nearest integer value in the same format; and
+<LI>
+comparisons between two values in the same floating-point format.
+</UL>
+</P>
+
+<P>
+The following operations required by the 2008 IEEE Floating-Point Standard are
+not supported in SoftFloat <NOBR>Release 3e</NOBR>:
+<UL>
+<LI>
+<B>nextUp</B>, <B>nextDown</B>, <B>minNum</B>, <B>maxNum</B>, <B>minNumMag</B>,
+<B>maxNumMag</B>, <B>scaleB</B>, and <B>logB</B>;
+<LI>
+conversions between floating-point formats and decimal or hexadecimal character
+sequences;
+<LI>
+all &ldquo;quiet-computation&rdquo; operations (<B>copy</B>, <B>negate</B>,
+<B>abs</B>, and <B>copySign</B>, which all involve only simple copying and/or
+manipulation of the floating-point sign bit); and
+<LI>
+all &ldquo;non-computational&rdquo; operations other than <B>isSignaling</B>
+(which is supported).
+</UL>
+</P>
+
+<H3>4.4. Non-canonical Representations in <CODE>extFloat80_t</CODE></H3>
+
+<P>
+Because the <NOBR>80-bit</NOBR> double-extended-precision format,
+<CODE>extFloat80_t</CODE>, stores an explicit leading significand bit, many
+finite floating-point numbers are encodable in this type in multiple equivalent
+forms.
+Of these multiple encodings, there is always a unique one with the least
+encoded exponent value, and this encoding is considered the <I>canonical</I>
+representation of the floating-point number.
+Any other equivalent representations (having a higher encoded exponent value)
+are <I>non-canonical</I>.
+For a value in the subnormal range (including zero), the canonical
+representation always has an encoded exponent of zero and a leading significand
+bit <NOBR>of 0</NOBR>.
+For finite values outside the subnormal range, the canonical representation
+always has an encoded exponent that is nonzero and a leading significand bit
+<NOBR>of 1</NOBR>.
+</P>
+
+<P>
+For an infinity or NaN, the leading significand bit is similarly expected to
+<NOBR>be 1</NOBR>.
+An infinity or NaN with a leading significand bit <NOBR>of 0</NOBR> is again
+considered non-canonical.
+Hence, altogether, to be canonical, a value of type <CODE>extFloat80_t</CODE>
+must have a leading significand bit <NOBR>of 1</NOBR>, unless the value is
+subnormal or zero, in which case the leading significand bit and the encoded
+exponent must both be zero.
+</P>
+
+<P>
+SoftFloat&rsquo;s functions are not guaranteed to operate as expected when
+inputs of type <CODE>extFloat80_t</CODE> are non-canonical.
+Assuming all of a function&rsquo;s <CODE>extFloat80_t</CODE> inputs (if any)
+are canonical, function outputs of type <CODE>extFloat80_t</CODE> will always
+be canonical.
+</P>
+
+<H3>4.5. Conventions for Passing Arguments and Results</H3>
+
+<P>
+Values that are at most <NOBR>64 bits</NOBR> in size (i.e., not the
+<NOBR>80-bit</NOBR> or <NOBR>128-bit</NOBR> floating-point formats) are in all
+cases passed as function arguments by value.
+Likewise, when an output of a function is no more than <NOBR>64 bits</NOBR>, it
+is always returned directly as the function result.
+Thus, for example, the SoftFloat function for adding two <NOBR>64-bit</NOBR>
+floating-point values has this simple signature:
+<BLOCKQUOTE>
+<CODE>float64_t f64_add( float64_t, float64_t );</CODE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+The story is more complex when function inputs and outputs are
+<NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> floating-point.
+For these types, SoftFloat always provides a function that passes these larger
+values into or out of the function indirectly, via pointers.
+For example, for adding two <NOBR>128-bit</NOBR> floating-point values,
+SoftFloat supplies this function:
+<BLOCKQUOTE>
+<CODE>void f128M_add( const float128_t *, const float128_t *, float128_t * );</CODE>
+</BLOCKQUOTE>
+The first two arguments point to the values to be added, and the last argument
+points to the location where the sum will be stored.
+The <CODE>M</CODE> in the name <CODE>f128M_add</CODE> is mnemonic for the fact
+that the <NOBR>128-bit</NOBR> inputs and outputs are &ldquo;in memory&rdquo;,
+pointed to by pointer arguments.
+</P>
+
+<P>
+All ports of SoftFloat implement these <I>pass-by-pointer</I> functions for
+types <CODE>extFloat80_t</CODE> and <CODE>float128_t</CODE>.
+At the same time, SoftFloat ports may also implement alternate versions of
+these same functions that pass <CODE>extFloat80_t</CODE> and
+<CODE>float128_t</CODE> by value, like the smaller formats.
+Thus, besides the function with name <CODE>f128M_add</CODE> shown above, a
+SoftFloat port may also supply an equivalent function with this signature:
+<BLOCKQUOTE>
+<CODE>float128_t f128_add( float128_t, float128_t );</CODE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+As a general rule, on computers where the machine word size is
+<NOBR>32 bits</NOBR> or smaller, only the pass-by-pointer versions of functions
+(e.g., <CODE>f128M_add</CODE>) are provided for types <CODE>extFloat80_t</CODE>
+and <CODE>float128_t</CODE>, because passing such large types directly can have
+significant extra cost.
+On computers where the word size is <NOBR>64 bits</NOBR> or larger, both
+function versions (<CODE>f128M_add</CODE> and <CODE>f128_add</CODE>) are
+provided, because the cost of passing by value is then more reasonable.
+Applications that must be portable across both classes of computers must use
+the pointer-based functions, as these are always implemented.
+However, if it is known that SoftFloat includes the by-value functions for all
+platforms of interest, programmers can use whichever version they prefer.
+</P>
+
+
+<H2>5. Reserved Names</H2>
+
+<P>
+In addition to the variables and functions documented here, SoftFloat defines
+some symbol names for its own private use.
+These private names always begin with the prefix
+&lsquo;<CODE>softfloat_</CODE>&rsquo;.
+When a program includes header <CODE>softfloat.h</CODE> or links with the
+SoftFloat library, all names with prefix &lsquo;<CODE>softfloat_</CODE>&rsquo;
+are reserved for possible use by SoftFloat.
+Applications that use SoftFloat should not define their own names with this
+prefix, and should reference only such names as are documented.
+</P>
+
+
+<H2>6. Mode Variables</H2>
+
+<P>
+The following global variables control rounding mode, underflow detection, and
+the <NOBR>80-bit</NOBR> extended format&rsquo;s rounding precision:
+<BLOCKQUOTE>
+<CODE>softfloat_roundingMode</CODE><BR>
+<CODE>softfloat_detectTininess</CODE><BR>
+<CODE>extF80_roundingPrecision</CODE>
+</BLOCKQUOTE>
+These mode variables are covered in the next several subsections.
+For some SoftFloat ports, these variables may be <I>per-thread</I> (declared
+<CODE>thread_local</CODE>), meaning that different execution threads have their
+own separate copies of the variables.
+</P>
+
+<H3>6.1. Rounding Mode</H3>
+
+<P>
+All five rounding modes defined by the 2008 IEEE Floating-Point Standard are
+implemented for all operations that require rounding.
+Some ports of SoftFloat may also implement the <I>round-to-odd</I> mode.
+</P>
+
+<P>
+The rounding mode is selected by the global variable
+<BLOCKQUOTE>
+<CODE>uint_fast8_t softfloat_roundingMode;</CODE>
+</BLOCKQUOTE>
+This variable may be set to one of the values
+<BLOCKQUOTE>
+<TABLE CELLSPACING=0 CELLPADDING=0>
+<TR>
+<TD><CODE>softfloat_round_near_even</CODE></TD>
+<TD>round to nearest, with ties to even</TD>
+</TR>
+<TR>
+<TD><CODE>softfloat_round_near_maxMag&nbsp;&nbsp;</CODE></TD>
+<TD>round to nearest, with ties to maximum magnitude (away from zero)</TD>
+</TR>
+<TR>
+<TD><CODE>softfloat_round_minMag</CODE></TD>
+<TD>round to minimum magnitude (toward zero)</TD>
+</TR>
+<TR>
+<TD><CODE>softfloat_round_min</CODE></TD>
+<TD>round to minimum (down)</TD>
+</TR>
+<TR>
+<TD><CODE>softfloat_round_max</CODE></TD>
+<TD>round to maximum (up)</TD>
+</TR>
+<TR>
+<TD><CODE>softfloat_round_odd</CODE></TD>
+<TD>round to odd (jamming), if supported by the SoftFloat port</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+Variable <CODE>softfloat_roundingMode</CODE> is initialized to
+<CODE>softfloat_round_near_even</CODE>.
+</P>
+
+<P>
+When <CODE>softfloat_round_odd</CODE> is the rounding mode for a function that
+rounds to an integer value (either conversion to an integer format or a
+&lsquo;<CODE>roundToInt</CODE>&rsquo; function), if the input is not already an
+integer, the rounded result is the closest <EM>odd</EM> integer.
+For other operations, this rounding mode acts as though the floating-point
+result is first rounded to minimum magnitude, the same as
+<CODE>softfloat_round_minMag</CODE>, and then, if the result is inexact, the
+least-significant bit of the result is set <NOBR>to 1</NOBR>.
+Rounding to odd is also known as <EM>jamming</EM>.
+</P>
+
+<H3>6.2. Underflow Detection</H3>
+
+<P>
+In the terminology of the IEEE Standard, SoftFloat can detect tininess for
+underflow either before or after rounding.
+The choice is made by the global variable
+<BLOCKQUOTE>
+<CODE>uint_fast8_t softfloat_detectTininess;</CODE>
+</BLOCKQUOTE>
+which can be set to either
+<BLOCKQUOTE>
+<CODE>softfloat_tininess_beforeRounding</CODE><BR>
+<CODE>softfloat_tininess_afterRounding</CODE>
+</BLOCKQUOTE>
+Detecting tininess after rounding is usually better because it results in fewer
+spurious underflow signals.
+The other option is provided for compatibility with some systems.
+Like most systems (and as required by the newer 2008 IEEE Standard), SoftFloat
+always detects loss of accuracy for underflow as an inexact result.
+</P>
+
+<H3>6.3. Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</H3>
+
+<P>
+For <CODE>extFloat80_t</CODE> only, the rounding precision of the basic
+arithmetic operations is controlled by the global variable
+<BLOCKQUOTE>
+<CODE>uint_fast8_t extF80_roundingPrecision;</CODE>
+</BLOCKQUOTE>
+The operations affected are:
+<BLOCKQUOTE>
+<CODE>extF80_add</CODE><BR>
+<CODE>extF80_sub</CODE><BR>
+<CODE>extF80_mul</CODE><BR>
+<CODE>extF80_div</CODE><BR>
+<CODE>extF80_sqrt</CODE>
+</BLOCKQUOTE>
+When <CODE>extF80_roundingPrecision</CODE> is set to its default value of 80,
+these operations are rounded to the full precision of the <NOBR>80-bit</NOBR>
+double-extended-precision format, like occurs for other formats.
+Setting <CODE>extF80_roundingPrecision</CODE> to 32 or to 64 causes the
+operations listed to be rounded to <NOBR>32-bit</NOBR> precision (equivalent to
+<CODE>float32_t</CODE>) or to <NOBR>64-bit</NOBR> precision (equivalent to
+<CODE>float64_t</CODE>), respectively.
+When rounding to reduced precision, additional bits in the result significand
+beyond the rounding point are set to zero.
+The consequences of setting <CODE>extF80_roundingPrecision</CODE> to a value
+other than 32, 64, or 80 is not specified.
+Operations other than the ones listed above are not affected by
+<CODE>extF80_roundingPrecision</CODE>.
+</P>
+
+
+<H2>7. Exceptions and Exception Flags</H2>
+
+<P>
+All five exception flags required by the IEEE Floating-Point Standard are
+implemented.
+Each flag is stored as a separate bit in the global variable
+<BLOCKQUOTE>
+<CODE>uint_fast8_t softfloat_exceptionFlags;</CODE>
+</BLOCKQUOTE>
+The positions of the exception flag bits within this variable are determined by
+the bit masks
+<BLOCKQUOTE>
+<CODE>softfloat_flag_inexact</CODE><BR>
+<CODE>softfloat_flag_underflow</CODE><BR>
+<CODE>softfloat_flag_overflow</CODE><BR>
+<CODE>softfloat_flag_infinite</CODE><BR>
+<CODE>softfloat_flag_invalid</CODE>
+</BLOCKQUOTE>
+Variable <CODE>softfloat_exceptionFlags</CODE> is initialized to all zeros,
+meaning no exceptions.
+</P>
+
+<P>
+For some SoftFloat ports, <CODE>softfloat_exceptionFlags</CODE> may be
+<I>per-thread</I> (declared <CODE>thread_local</CODE>), meaning that different
+execution threads have their own separate instances of it.
+</P>
+
+<P>
+An individual exception flag can be cleared with the statement
+<BLOCKQUOTE>
+<CODE>softfloat_exceptionFlags &= ~softfloat_flag_&lt;<I>exception</I>&gt;;</CODE>
+</BLOCKQUOTE>
+where <CODE>&lt;<I>exception</I>&gt;</CODE> is the appropriate name.
+To raise a floating-point exception, function <CODE>softfloat_raiseFlags</CODE>
+should normally be used.
+</P>
+
+<P>
+When SoftFloat detects an exception other than <I>inexact</I>, it calls
+<CODE>softfloat_raiseFlags</CODE>.
+The default version of this function simply raises the corresponding exception
+flags.
+Particular ports of SoftFloat may support alternate behavior, such as exception
+traps, by modifying the default <CODE>softfloat_raiseFlags</CODE>.
+A program may also supply its own <CODE>softfloat_raiseFlags</CODE> function to
+override the one from the SoftFloat library.
+</P>
+
+<P>
+Because inexact results occur frequently under most circumstances (and thus are
+hardly exceptional), SoftFloat does not ordinarily call
+<CODE>softfloat_raiseFlags</CODE> for <I>inexact</I> exceptions.
+It does always raise the <I>inexact</I> exception flag as required.
+</P>
+
+
+<H2>8. Function Details</H2>
+
+<P>
+In this section, <CODE>&lt;<I>float</I>&gt;</CODE> appears in function names as
+a substitute for one of these abbreviations:
+<BLOCKQUOTE>
+<TABLE CELLSPACING=0 CELLPADDING=0>
+<TR>
+<TD><CODE>f16</CODE></TD>
+<TD>indicates <CODE>float16_t</CODE>, passed by value</TD>
+</TR>
+<TR>
+<TD><CODE>f32</CODE></TD>
+<TD>indicates <CODE>float32_t</CODE>, passed by value</TD>
+</TR>
+<TR>
+<TD><CODE>f64</CODE></TD>
+<TD>indicates <CODE>float64_t</CODE>, passed by value</TD>
+</TR>
+<TR>
+<TD><CODE>extF80M&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD>indicates <CODE>extFloat80_t</CODE>, passed indirectly via pointers</TD>
+</TR>
+<TR>
+<TD><CODE>extF80</CODE></TD>
+<TD>indicates <CODE>extFloat80_t</CODE>, passed by value</TD>
+</TR>
+<TR>
+<TD><CODE>f128M</CODE></TD>
+<TD>indicates <CODE>float128_t</CODE>, passed indirectly via pointers</TD>
+</TR>
+<TR>
+<TD><CODE>f128</CODE></TD>
+<TD>indicates <CODE>float128_t</CODE>, passed by value</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+The circumstances under which values of floating-point types
+<CODE>extFloat80_t</CODE> and <CODE>float128_t</CODE> may be passed either by
+value or indirectly via pointers was discussed earlier in
+<NOBR>section 4.5</NOBR>, <I>Conventions for Passing Arguments and Results</I>.
+</P>
+
+<H3>8.1. Conversions from Integer to Floating-Point</H3>
+
+<P>
+All conversions from a <NOBR>32-bit</NOBR> or <NOBR>64-bit</NOBR> integer,
+signed or unsigned, to a floating-point format are supported.
+Functions performing these conversions have these names:
+<BLOCKQUOTE>
+<CODE>ui32_to_&lt;<I>float</I>&gt;</CODE><BR>
+<CODE>ui64_to_&lt;<I>float</I>&gt;</CODE><BR>
+<CODE>i32_to_&lt;<I>float</I>&gt;</CODE><BR>
+<CODE>i64_to_&lt;<I>float</I>&gt;</CODE>
+</BLOCKQUOTE>
+Conversions from <NOBR>32-bit</NOBR> integers to <NOBR>64-bit</NOBR>
+double-precision and larger formats are always exact, and likewise conversions
+from <NOBR>64-bit</NOBR> integers to <NOBR>80-bit</NOBR>
+double-extended-precision and <NOBR>128-bit</NOBR> quadruple-precision are also
+always exact.
+</P>
+
+<P>
+Each conversion function takes one input of the appropriate type and generates
+one output.
+The following illustrates the signatures of these functions in cases when the
+floating-point result is passed either by value or via pointers:
+<BLOCKQUOTE>
+<PRE>
+float64_t i32_to_f64( int32_t <I>a</I> );
+</PRE>
+<PRE>
+void i32_to_f128M( int32_t <I>a</I>, float128_t *<I>destPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<H3>8.2. Conversions from Floating-Point to Integer</H3>
+
+<P>
+Conversions from a floating-point format to a <NOBR>32-bit</NOBR> or
+<NOBR>64-bit</NOBR> integer, signed or unsigned, are supported with these
+functions:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_to_ui32</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_ui64</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_i32</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_i64</CODE>
+</BLOCKQUOTE>
+The functions have signatures as follows, depending on whether the
+floating-point input is passed by value or via pointers:
+<BLOCKQUOTE>
+<PRE>
+int_fast32_t f64_to_i32( float64_t <I>a</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
+</PRE>
+<PRE>
+int_fast32_t
+ f128M_to_i32( const float128_t *<I>aPtr</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+The <CODE><I>roundingMode</I></CODE> argument specifies the rounding mode for
+the conversion.
+The variable that usually indicates rounding mode,
+<CODE>softfloat_roundingMode</CODE>, is ignored.
+Argument <CODE><I>exact</I></CODE> determines whether the <I>inexact</I>
+exception flag is raised if the conversion is not exact.
+If <CODE><I>exact</I></CODE> is <CODE>true</CODE>, the <I>inexact</I> flag may
+be raised;
+otherwise, it will not be, even if the conversion is inexact.
+</P>
+
+<P>
+A conversion from floating-point to integer format raises the <I>invalid</I>
+exception if the source value cannot be rounded to a representable integer of
+the desired size (32 or 64 bits).
+In such circumstances, the integer result returned is determined by the
+particular port of SoftFloat, although typically this value will be either the
+maximum or minimum value of the integer format.
+The functions that convert to integer types never raise the floating-point
+<I>overflow</I> exception.
+</P>
+
+<P>
+Because languages such <NOBR>as C</NOBR> require that conversions to integers
+be rounded toward zero, the following functions are provided for improved speed
+and convenience:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_to_ui32_r_minMag</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_ui64_r_minMag</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_i32_r_minMag</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_to_i64_r_minMag</CODE>
+</BLOCKQUOTE>
+These functions round only toward zero (to minimum magnitude).
+The signatures for these functions are the same as above without the redundant
+<CODE><I>roundingMode</I></CODE> argument:
+<BLOCKQUOTE>
+<PRE>
+int_fast32_t f64_to_i32_r_minMag( float64_t <I>a</I>, bool <I>exact</I> );
+</PRE>
+<PRE>
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *<I>aPtr</I>, bool <I>exact</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<H3>8.3. Conversions Among Floating-Point Types</H3>
+
+<P>
+Conversions between floating-point formats are done by functions with these
+names:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_to_&lt;<I>float</I>&gt;</CODE>
+</BLOCKQUOTE>
+All combinations of source and result type are supported where the source and
+result are different formats.
+There are four different styles of signature for these functions, depending on
+whether the input and the output floating-point values are passed by value or
+via pointers:
+<BLOCKQUOTE>
+<PRE>
+float32_t f64_to_f32( float64_t <I>a</I> );
+</PRE>
+<PRE>
+float32_t f128M_to_f32( const float128_t *<I>aPtr</I> );
+</PRE>
+<PRE>
+void f32_to_f128M( float32_t <I>a</I>, float128_t *<I>destPtr</I> );
+</PRE>
+<PRE>
+void extF80M_to_f128M( const extFloat80_t *<I>aPtr</I>, float128_t *<I>destPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+Conversions from a smaller to a larger floating-point format are always exact
+and so require no rounding.
+</P>
+
+<H3>8.4. Basic Arithmetic Functions</H3>
+
+<P>
+The following basic arithmetic functions are provided:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_add</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_sub</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_mul</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_div</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_sqrt</CODE>
+</BLOCKQUOTE>
+Each floating-point operation takes two operands, except for <CODE>sqrt</CODE>
+(square root) which takes only one.
+The operands and result are all of the same floating-point format.
+Signatures for these functions take the following forms:
+<BLOCKQUOTE>
+<PRE>
+float64_t f64_add( float64_t <I>a</I>, float64_t <I>b</I> );
+</PRE>
+<PRE>
+void
+ f128M_add(
+     const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I>, float128_t *<I>destPtr</I> );
+</PRE>
+<PRE>
+float64_t f64_sqrt( float64_t <I>a</I> );
+</PRE>
+<PRE>
+void f128M_sqrt( const float128_t *<I>aPtr</I>, float128_t *<I>destPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+When floating-point values are passed indirectly through pointers, arguments
+<CODE><I>aPtr</I></CODE> and <CODE><I>bPtr</I></CODE> point to the input
+operands, and the last argument, <CODE><I>destPtr</I></CODE>, points to the
+location where the result is stored.
+</P>
+
+<P>
+Rounding of the <NOBR>80-bit</NOBR> double-extended-precision
+(<CODE>extFloat80_t</CODE>) functions is affected by variable
+<CODE>extF80_roundingPrecision</CODE>, as explained earlier in
+<NOBR>section 6.3</NOBR>,
+<I>Rounding Precision for the <NOBR>80-Bit</NOBR> Extended Format</I>.
+</P>
+
+<H3>8.5. Fused Multiply-Add Functions</H3>
+
+<P>
+The 2008 version of the IEEE Floating-Point Standard defines a <I>fused
+multiply-add</I> operation that does a combined multiplication and addition
+with only a single rounding.
+SoftFloat implements fused multiply-add with functions
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_mulAdd</CODE>
+</BLOCKQUOTE>
+Unlike other operations, fused multiple-add is not supported for the
+<NOBR>80-bit</NOBR> double-extended-precision format,
+<CODE>extFloat80_t</CODE>.
+</P>
+
+<P>
+Depending on whether floating-point values are passed by value or via pointers,
+the fused multiply-add functions have signatures of these forms:
+<BLOCKQUOTE>
+<PRE>
+float64_t f64_mulAdd( float64_t <I>a</I>, float64_t <I>b</I>, float64_t <I>c</I> );
+</PRE>
+<PRE>
+void
+ f128M_mulAdd(
+     const float128_t *<I>aPtr</I>,
+     const float128_t *<I>bPtr</I>,
+     const float128_t *<I>cPtr</I>,
+     float128_t *<I>destPtr</I>
+ );
+</PRE>
+</BLOCKQUOTE>
+The functions compute
+<NOBR>(<CODE><I>a</I></CODE> &times; <CODE><I>b</I></CODE>)
+ + <CODE><I>c</I></CODE></NOBR>
+with a single rounding.
+When floating-point values are passed indirectly through pointers, arguments
+<CODE><I>aPtr</I></CODE>, <CODE><I>bPtr</I></CODE>, and
+<CODE><I>cPtr</I></CODE> point to operands <CODE><I>a</I></CODE>,
+<CODE><I>b</I></CODE>, and <CODE><I>c</I></CODE> respectively, and
+<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
+</P>
+
+<P>
+If one of the multiplication operands <CODE><I>a</I></CODE> and
+<CODE><I>b</I></CODE> is infinite and the other is zero, these functions raise
+the invalid exception even if operand <CODE><I>c</I></CODE> is a quiet NaN.
+</P>
+
+<H3>8.6. Remainder Functions</H3>
+
+<P>
+For each format, SoftFloat implements the remainder operation defined by the
+IEEE Floating-Point Standard.
+The remainder functions have names
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_rem</CODE>
+</BLOCKQUOTE>
+Each remainder operation takes two floating-point operands of the same format
+and returns a result in the same format.
+Depending on whether floating-point values are passed by value or via pointers,
+the remainder functions have signatures of these forms:
+<BLOCKQUOTE>
+<PRE>
+float64_t f64_rem( float64_t <I>a</I>, float64_t <I>b</I> );
+</PRE>
+<PRE>
+void
+ f128M_rem(
+     const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I>, float128_t *<I>destPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+When floating-point values are passed indirectly through pointers, arguments
+<CODE><I>aPtr</I></CODE> and <CODE><I>bPtr</I></CODE> point to operands
+<CODE><I>a</I></CODE> and <CODE><I>b</I></CODE> respectively, and
+<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
+</P>
+
+<P>
+The IEEE Standard remainder operation computes the value
+<NOBR><CODE><I>a</I></CODE>
+ &minus; <I>n</I> &times; <CODE><I>b</I></CODE></NOBR>,
+where <I>n</I> is the integer closest to
+<NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR>.
+If <NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR> is exactly
+halfway between two integers, <I>n</I> is the <EM>even</EM> integer closest to
+<NOBR><CODE><I>a</I></CODE> &divide; <CODE><I>b</I></CODE></NOBR>.
+The IEEE Standard&rsquo;s remainder operation is always exact and so requires
+no rounding.
+</P>
+
+<P>
+Depending on the relative magnitudes of the operands, the remainder
+functions can take considerably longer to execute than the other SoftFloat
+functions.
+This is an inherent characteristic of the remainder operation itself and is not
+a flaw in the SoftFloat implementation.
+</P>
+
+<H3>8.7. Round-to-Integer Functions</H3>
+
+<P>
+For each format, SoftFloat implements the round-to-integer operation specified
+by the IEEE Floating-Point Standard.
+These functions are named
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_roundToInt</CODE>
+</BLOCKQUOTE>
+Each round-to-integer operation takes a single floating-point operand.
+This operand is rounded to an integer according to a specified rounding mode,
+and the resulting integer value is returned in the same floating-point format.
+(Note that the result is not an integer type.)
+</P>
+
+<P>
+The signatures of the round-to-integer functions are similar to those for
+conversions to an integer type:
+<BLOCKQUOTE>
+<PRE>
+float64_t f64_roundToInt( float64_t <I>a</I>, uint_fast8_t <I>roundingMode</I>, bool <I>exact</I> );
+</PRE>
+<PRE>
+void
+ f128M_roundToInt(
+     const float128_t *<I>aPtr</I>,
+     uint_fast8_t <I>roundingMode</I>,
+     bool <I>exact</I>,
+     float128_t *<I>destPtr</I>
+ );
+</PRE>
+</BLOCKQUOTE>
+When floating-point values are passed indirectly through pointers,
+<CODE><I>aPtr</I></CODE> points to the input operand and
+<CODE><I>destPtr</I></CODE> points to the location where the result is stored.
+</P>
+
+<P>
+The <CODE><I>roundingMode</I></CODE> argument specifies the rounding mode to
+apply.
+The variable that usually indicates rounding mode,
+<CODE>softfloat_roundingMode</CODE>, is ignored.
+Argument <CODE><I>exact</I></CODE> determines whether the <I>inexact</I>
+exception flag is raised if the conversion is not exact.
+If <CODE><I>exact</I></CODE> is <CODE>true</CODE>, the <I>inexact</I> flag may
+be raised;
+otherwise, it will not be, even if the conversion is inexact.
+</P>
+
+<H3>8.8. Comparison Functions</H3>
+
+<P>
+For each format, the following floating-point comparison functions are
+provided:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_eq</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_le</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_lt</CODE>
+</BLOCKQUOTE>
+Each comparison takes two operands of the same type and returns a Boolean.
+The abbreviation <CODE>eq</CODE> stands for &ldquo;equal&rdquo; (=);
+<CODE>le</CODE> stands for &ldquo;less than or equal&rdquo; (&le;);
+and <CODE>lt</CODE> stands for &ldquo;less than&rdquo; (&lt;).
+Depending on whether the floating-point operands are passed by value or via
+pointers, the comparison functions have signatures of these forms:
+<BLOCKQUOTE>
+<PRE>
+bool f64_eq( float64_t <I>a</I>, float64_t <I>b</I> );
+</PRE>
+<PRE>
+bool f128M_eq( const float128_t *<I>aPtr</I>, const float128_t *<I>bPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+The usual greater-than (&gt;), greater-than-or-equal (&ge;), and not-equal
+(&ne;) comparisons are easily obtained from the functions provided.
+The not-equal function is just the logical complement of the equal function.
+The greater-than-or-equal function is identical to the less-than-or-equal
+function with the arguments in reverse order, and likewise the greater-than
+function is identical to the less-than function with the arguments reversed.
+</P>
+
+<P>
+The IEEE Floating-Point Standard specifies that the less-than-or-equal and
+less-than comparisons by default raise the <I>invalid</I> exception if either
+operand is any kind of NaN.
+Equality comparisons, on the other hand, are defined by default to raise the
+<I>invalid</I> exception only for signaling NaNs, not quiet NaNs.
+For completeness, SoftFloat provides these complementary functions:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_eq_signaling</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_le_quiet</CODE><BR>
+<CODE>&lt;<I>float</I>&gt;_lt_quiet</CODE>
+</BLOCKQUOTE>
+The <CODE>signaling</CODE> equality comparisons are identical to the default
+equality comparisons except that the <I>invalid</I> exception is raised for any
+NaN input, not just for signaling NaNs.
+Similarly, the <CODE>quiet</CODE> comparison functions are identical to their
+default counterparts except that the <I>invalid</I> exception is not raised for
+quiet NaNs.
+</P>
+
+<H3>8.9. Signaling NaN Test Functions</H3>
+
+<P>
+Functions for testing whether a floating-point value is a signaling NaN are
+provided with these names:
+<BLOCKQUOTE>
+<CODE>&lt;<I>float</I>&gt;_isSignalingNaN</CODE>
+</BLOCKQUOTE>
+The functions take one floating-point operand and return a Boolean indicating
+whether the operand is a signaling NaN.
+Accordingly, the functions have the forms
+<BLOCKQUOTE>
+<PRE>
+bool f64_isSignalingNaN( float64_t <I>a</I> );
+</PRE>
+<PRE>
+bool f128M_isSignalingNaN( const float128_t *<I>aPtr</I> );
+</PRE>
+</BLOCKQUOTE>
+</P>
+
+<H3>8.10. Raise-Exception Function</H3>
+
+<P>
+SoftFloat provides a single function for raising floating-point exceptions:
+<BLOCKQUOTE>
+<PRE>
+void softfloat_raiseFlags( uint_fast8_t <I>exceptions</I> );
+</PRE>
+</BLOCKQUOTE>
+The <CODE><I>exceptions</I></CODE> argument is a mask indicating the set of
+exceptions to raise.
+(See earlier section 7, <I>Exceptions and Exception Flags</I>.)
+In addition to setting the specified exception flags in variable
+<CODE>softfloat_exceptionFlags</CODE>, the <CODE>softfloat_raiseFlags</CODE>
+function may cause a trap or abort appropriate for the current system.
+</P>
+
+
+<H2>9. Changes from SoftFloat <NOBR>Release 2</NOBR></H2>
+
+<P>
+Apart from a change in the legal use license, <NOBR>Release 3</NOBR> of
+SoftFloat introduced numerous technical differences compared to earlier
+releases.
+</P>
+
+<H3>9.1. Name Changes</H3>
+
+<P>
+The most obvious and pervasive difference compared to <NOBR>Release 2</NOBR>
+is that the names of most functions and variables have changed, even when the
+behavior has not.
+First, the floating-point types, the mode variables, the exception flags
+variable, the function to raise exceptions, and various associated constants
+have been renamed as follows:
+<BLOCKQUOTE>
+<TABLE>
+<TR>
+<TD>old name, Release 2:</TD>
+<TD>new name, Release 3:</TD>
+</TR>
+<TR>
+<TD><CODE>float32</CODE></TD>
+<TD><CODE>float32_t</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float64</CODE></TD>
+<TD><CODE>float64_t</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>floatx80</CODE></TD>
+<TD><CODE>extFloat80_t</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float128</CODE></TD>
+<TD><CODE>float128_t</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_rounding_mode</CODE></TD>
+<TD><CODE>softfloat_roundingMode</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_round_nearest_even</CODE></TD>
+<TD><CODE>softfloat_round_near_even</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_round_to_zero</CODE></TD>
+<TD><CODE>softfloat_round_minMag</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_round_down</CODE></TD>
+<TD><CODE>softfloat_round_min</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_round_up</CODE></TD>
+<TD><CODE>softfloat_round_max</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_detect_tininess</CODE></TD>
+<TD><CODE>softfloat_detectTininess</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_tininess_before_rounding&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD><CODE>softfloat_tininess_beforeRounding</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_tininess_after_rounding</CODE></TD>
+<TD><CODE>softfloat_tininess_afterRounding</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>floatx80_rounding_precision</CODE></TD>
+<TD><CODE>extF80_roundingPrecision</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_exception_flags</CODE></TD>
+<TD><CODE>softfloat_exceptionFlags</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_flag_inexact</CODE></TD>
+<TD><CODE>softfloat_flag_inexact</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_flag_underflow</CODE></TD>
+<TD><CODE>softfloat_flag_underflow</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_flag_overflow</CODE></TD>
+<TD><CODE>softfloat_flag_overflow</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_flag_divbyzero</CODE></TD>
+<TD><CODE>softfloat_flag_infinite</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_flag_invalid</CODE></TD>
+<TD><CODE>softfloat_flag_invalid</CODE></TD>
+</TR>
+<TR>
+<TD><CODE>float_raise</CODE></TD>
+<TD><CODE>softfloat_raiseFlags</CODE></TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+</P>
+
+<P>
+Furthermore, <NOBR>Release 3</NOBR> adopted the following new abbreviations for
+function names:
+<BLOCKQUOTE>
+<TABLE>
+<TR>
+<TD>used in names in Release 2:<CODE>&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD>used in names in Release 3:</TD>
+</TR>
+<TR> <TD><CODE>int32</CODE></TD>    <TD><CODE>i32</CODE></TD>    </TR>
+<TR> <TD><CODE>int64</CODE></TD>    <TD><CODE>i64</CODE></TD>    </TR>
+<TR> <TD><CODE>float32</CODE></TD>  <TD><CODE>f32</CODE></TD>    </TR>
+<TR> <TD><CODE>float64</CODE></TD>  <TD><CODE>f64</CODE></TD>    </TR>
+<TR> <TD><CODE>floatx80</CODE></TD> <TD><CODE>extF80</CODE></TD> </TR>
+<TR> <TD><CODE>float128</CODE></TD> <TD><CODE>f128</CODE></TD>   </TR>
+</TABLE>
+</BLOCKQUOTE>
+Thus, for example, the function to add two <NOBR>32-bit</NOBR> floating-point
+numbers, previously called <CODE>float32_add</CODE> in <NOBR>Release 2</NOBR>,
+is now <CODE>f32_add</CODE>.
+Lastly, there have been a few other changes to function names:
+<BLOCKQUOTE>
+<TABLE>
+<TR>
+<TD>used in names in Release 2:<CODE>&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD>used in names in Release 3:<CODE>&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD>relevant functions:</TD>
+</TR>
+<TR>
+<TD><CODE>_round_to_zero</CODE></TD>
+<TD><CODE>_r_minMag</CODE></TD>
+<TD>conversions from floating-point to integer (<NOBR>section 8.2</NOBR>)</TD>
+</TR>
+<TR>
+<TD><CODE>round_to_int</CODE></TD>
+<TD><CODE>roundToInt</CODE></TD>
+<TD>round-to-integer functions (<NOBR>section 8.7</NOBR>)</TD>
+</TR>
+<TR>
+<TD><CODE>is_signaling_nan&nbsp;&nbsp;&nbsp;&nbsp;</CODE></TD>
+<TD><CODE>isSignalingNaN</CODE></TD>
+<TD>signaling NaN test functions (<NOBR>section 8.9</NOBR>)</TD>
+</TR>
+</TABLE>
+</BLOCKQUOTE>
+</P>
+
+<H3>9.2. Changes to Function Arguments</H3>
+
+<P>
+Besides simple name changes, some operations were given a different interface
+in <NOBR>Release 3</NOBR> than they had in <NOBR>Release 2</NOBR>:
+<UL>
+
+<LI>
+<P>
+Since <NOBR>Release 3</NOBR>, integer arguments and results of functions have
+standard types from header <CODE>&lt;stdint.h&gt;</CODE>, such as
+<CODE>uint32_t</CODE>, whereas previously their types could be defined
+differently for each port of SoftFloat, usually using traditional C types such
+as <CODE>unsigned</CODE> <CODE>int</CODE>.
+Likewise, functions in <NOBR>Release 3</NOBR> and later pass Booleans as
+standard type <CODE>bool</CODE> from <CODE>&lt;stdbool.h&gt;</CODE>, whereas
+previously these were again passed as a port-specific type (usually
+<CODE>int</CODE>).
+</P>
+
+<LI>
+<P>
+As explained earlier in <NOBR>section 4.5</NOBR>, <I>Conventions for Passing
+Arguments and Results</I>, SoftFloat functions in <NOBR>Release 3</NOBR> and
+later may pass <NOBR>80-bit</NOBR> and <NOBR>128-bit</NOBR> floating-point
+values through pointers, meaning that functions take pointer arguments and then
+read or write floating-point values at the locations indicated by the pointers.
+In <NOBR>Release 2</NOBR>, floating-point arguments and results were always
+passed by value, regardless of their size.
+</P>
+
+<LI>
+<P>
+Functions that round to an integer have additional
+<CODE><I>roundingMode</I></CODE> and <CODE><I>exact</I></CODE> arguments that
+they did not have in <NOBR>Release 2</NOBR>.
+Refer to sections 8.2 <NOBR>and 8.7</NOBR> for descriptions of these functions
+since <NOBR>Release 3</NOBR>.
+For <NOBR>Release 2</NOBR>, the rounding mode, when needed, was taken from the
+same global variable that affects the basic arithmetic operations (now called
+<CODE>softfloat_roundingMode</CODE> but previously known as
+<CODE>float_rounding_mode</CODE>).
+Also, for <NOBR>Release 2</NOBR>, if the original floating-point input was not
+an exact integer value, and if the <I>invalid</I> exception was not raised by
+the function, the <I>inexact</I> exception was always raised.
+<NOBR>Release 2</NOBR> had no option to suppress raising <I>inexact</I> in this
+case.
+Applications using SoftFloat <NOBR>Release 3</NOBR> or later can get the same
+effect as <NOBR>Release 2</NOBR> by passing variable
+<CODE>softfloat_roundingMode</CODE> for argument
+<CODE><I>roundingMode</I></CODE> and <CODE>true</CODE> for argument
+<CODE><I>exact</I></CODE>.
+</P>
+
+</UL>
+</P>
+
+<H3>9.3. Added Capabilities</H3>
+
+<P>
+With <NOBR>Release 3</NOBR>, some new features have been added that were not
+present in <NOBR>Release 2</NOBR>:
+<UL>
+
+<LI>
+<P>
+A port of SoftFloat can now define any of the floating-point types
+<CODE>float32_t</CODE>, <CODE>float64_t</CODE>, <CODE>extFloat80_t</CODE>, and
+<CODE>float128_t</CODE> as aliases for C&rsquo;s standard floating-point types
+<CODE>float</CODE>, <CODE>double</CODE>, and <CODE>long</CODE>
+<CODE>double</CODE>, using either <CODE>#define</CODE> or <CODE>typedef</CODE>.
+This potential convenience was not supported under <NOBR>Release 2</NOBR>.
+</P>
+
+<P>
+(Note, however, that there may be a performance cost to defining
+SoftFloat&rsquo;s floating-point types this way, depending on the platform and
+the applications using SoftFloat.
+Ports of SoftFloat may choose to forgo the convenience in favor of better
+speed.)
+</P>
+
+<P>
+<LI>
+As of <NOBR>Release 3b</NOBR>, <NOBR>16-bit</NOBR> half-precision,
+<CODE>float16_t</CODE>, is supported.
+</P>
+
+<P>
+<LI>
+Functions have been added for converting between the floating-point types and
+unsigned integers.
+<NOBR>Release 2</NOBR> supported only signed integers, not unsigned.
+</P>
+
+<P>
+<LI>
+Fused multiply-add functions have been added for all floating-point formats
+except <NOBR>80-bit</NOBR> double-extended-precision,
+<CODE>extFloat80_t</CODE>.
+</P>
+
+<P>
+<LI>
+New rounding modes are supported:
+<CODE>softfloat_round_near_maxMag</CODE> (round to nearest, with ties to
+maximum magnitude, away from zero), and, as of <NOBR>Release 3c</NOBR>,
+optional <CODE>softfloat_round_odd</CODE> (round to odd, also known as
+jamming).
+</P>
+
+</UL>
+</P>
+
+<H3>9.4. Better Compatibility with the C Language</H3>
+
+<P>
+<NOBR>Release 3</NOBR> of SoftFloat was written to conform better to the ISO C
+Standard&rsquo;s rules for portability.
+For example, older releases of SoftFloat employed type conversions in ways
+that, while commonly practiced, are not fully defined by the C Standard.
+Such problematic type conversions have generally been replaced by the use of
+unions, the behavior around which is more strictly regulated these days.
+</P>
+
+<H3>9.5. New Organization as a Library</H3>
+
+<P>
+Starting with <NOBR>Release 3</NOBR>, SoftFloat now builds as a library.
+Previously, SoftFloat compiled into a single, monolithic object file containing
+all the SoftFloat functions, with the consequence that a program linking with
+SoftFloat would get every SoftFloat function in its binary file even if only a
+few functions were actually used.
+With SoftFloat in the form of a library, a program that is linked by a standard
+linker will include only those functions of SoftFloat that it needs and no
+others.
+</P>
+
+<H3>9.6. Optimization Gains (and Losses)</H3>
+
+<P>
+Individual SoftFloat functions have been variously improved in
+<NOBR>Release 3</NOBR> compared to earlier releases.
+In particular, better, faster algorithms have been deployed for the operations
+of division, square root, and remainder.
+For functions operating on the larger <NOBR>80-bit</NOBR> and
+<NOBR>128-bit</NOBR> formats, <CODE>extFloat80_t</CODE> and
+<CODE>float128_t</CODE>, code size has also generally been reduced.
+</P>
+
+<P>
+However, because <NOBR>Release 2</NOBR> compiled all of SoftFloat together as a
+single object file, compilers could make optimizations across function calls
+when one SoftFloat function calls another.
+Now that the functions of SoftFloat are compiled separately and only afterward
+linked together into a program, there is not usually the same opportunity to
+optimize across function calls.
+Some loss of speed has been observed due to this change.
+</P>
+
+
+<H2>10. Future Directions</H2>
+
+<P>
+The following improvements are anticipated for future releases of SoftFloat:
+<UL>
+<LI>
+more functions from the 2008 version of the IEEE Floating-Point Standard;
+<LI>
+consistent, defined behavior for non-canonical representations of extended
+format <CODE>extFloat80_t</CODE> (discussed in <NOBR>section 4.4</NOBR>,
+<I>Non-canonical Representations in <CODE>extFloat80_t</CODE></I>).
+
+</UL>
+</P>
+
+
+<H2>11. Contact Information</H2>
+
+<P>
+At the time of this writing, the most up-to-date information about SoftFloat
+and the latest release can be found at the Web page
+<A HREF="http://www.jhauser.us/arithmetic/SoftFloat.html"><NOBR><CODE>http://www.jhauser.us/arithmetic/SoftFloat.html</CODE></NOBR></A>.
+</P>
+
+
+</BODY>
+
diff --git a/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c b/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
index 85ee211..c2cca65 100644
--- a/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
+++ b/softfloat/source/8086-SSE/extF80M_isSignalingNaN.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint64_t uiA0;
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
-    uiA0 = aSPtr->signif;
-    return
-        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
-            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint64_t uiA0;
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+    uiA0 = aSPtr->signif;
+    return
+        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/softfloat/source/8086-SSE/f128M_isSignalingNaN.c b/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
index 79a7077..9ff83d7 100644
--- a/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
+++ b/softfloat/source/8086-SSE/f128M_isSignalingNaN.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool f128M_isSignalingNaN( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
-    return
-        ((uiA96 & 0x00007FFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+    return
+        ((uiA96 & 0x00007FFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c b/softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
new file mode 100644
index 0000000..c1c774d
--- /dev/null
+++ b/softfloat/source/8086-SSE/s_bf16UIToCommonNaN.c
@@ -0,0 +1,59 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a BF16 NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNBF16UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>15;
+    zPtr->v64  = (uint_fast64_t) uiA<<56;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToBF16UI.c b/softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
new file mode 100644
index 0000000..d81cf51
--- /dev/null
+++ b/softfloat/source/8086-SSE/s_commonNaNToBF16UI.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a BF16 NaN, and 
+| returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast16_t) aPtr->sign<<15 | 0x7FC0 | aPtr->v64>>56;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c b/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
index 3405b3b..06302aa 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToExtF80M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| `zSPtr'.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
-
-    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
-    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| `zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c b/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
index cb7424f..7325468 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToExtF80UI.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
-    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToF128M.c b/softfloat/source/8086-SSE/s_commonNaNToF128M.c
index e7ea802..e2940bb 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToF128M.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToF128M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
-| `zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-
-    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
-    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
+| `zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToF128UI.c b/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
index 7a9423b..ac8ea7b 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToF128UI.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
-    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToF16UI.c b/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
index d4e458a..07679d7 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToF16UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToF32UI.c b/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
index ed6c226..982c1ed 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToF32UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_commonNaNToF64UI.c b/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
index 1182be3..d88c68a 100644
--- a/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
+++ b/softfloat/source/8086-SSE/s_commonNaNToF64UI.c
@@ -1,53 +1,53 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
-{
-
-    return
-        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
-            | aPtr->v64>>12;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+    return
+        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+            | aPtr->v64>>12;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c b/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
index 00baf35..6bf45cf 100644
--- a/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_extF80MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by `zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
-{
-
-    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = signExtF80UI64( aSPtr->signExp );
-    zPtr->v64 = aSPtr->signif<<1;
-    zPtr->v0  = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by `zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = signExtF80UI64( aSPtr->signExp );
+    zPtr->v64 = aSPtr->signif<<1;
+    zPtr->v0  = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c b/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
index ab6311e..8b8c927 100644
--- a/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_extF80UIToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA64>>15;
-    zPtr->v64  = uiA0<<1;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA64>>15;
+    zPtr->v64  = uiA0<<1;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_f128MToCommonNaN.c b/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
index 55ec25b..2215214 100644
--- a/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_f128MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by `zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument `aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
-{
-
-    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
-    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by `zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument `aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c b/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
index f838f02..2510c07 100644
--- a/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_f128UIToCommonNaN.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-    struct uint128 NaNSig;
-
-    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
-    zPtr->sign = uiA64>>63;
-    zPtr->v64  = NaNSig.v64;
-    zPtr->v0   = NaNSig.v0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+    struct uint128 NaNSig;
+
+    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+    zPtr->sign = uiA64>>63;
+    zPtr->v64  = NaNSig.v64;
+    zPtr->v0   = NaNSig.v0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c b/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
index c1e242d..4d5003f 100644
--- a/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_f16UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>15;
-    zPtr->v64  = (uint_fast64_t) uiA<<54;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF16UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>15;
+    zPtr->v64  = (uint_fast64_t) uiA<<54;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c b/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
index b21ba66..f4734db 100644
--- a/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_f32UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>31;
-    zPtr->v64  = (uint_fast64_t) uiA<<41;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF32UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>31;
+    zPtr->v64  = (uint_fast64_t) uiA<<41;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c b/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
index 6529d2e..9a481a7 100644
--- a/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
+++ b/softfloat/source/8086-SSE/s_f64UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>63;
-    zPtr->v64  = uiA<<12;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF64UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>63;
+    zPtr->v64  = uiA<<12;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c b/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
index ea1d57a..f35e066 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNExtF80M.c
@@ -1,107 +1,107 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by `zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    bool isSigNaNA;
-    const struct extFloat80M *sPtr;
-    bool isSigNaNB;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiMagA64, uiMagB64;
-
-    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
-    sPtr = aSPtr;
-    if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
-        goto copy;
-    }
-    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            uiB64 = bSPtr->signExp;
-            if ( isSigNaNB ) goto returnLargerUIMag;
-            uiB0 = bSPtr->signif;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
-            goto copy;
-        } else {
-            uiA64 = aSPtr->signExp;
-            uiA0 = aSPtr->signif;
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
-            goto copyB;
-        }
-    }
-    uiB64 = bSPtr->signExp;
- returnLargerUIMag:
-    uiA64 = aSPtr->signExp;
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto copyB;
-    if ( uiMagB64 < uiMagA64 ) goto copy;
-    uiA0 = aSPtr->signif;
-    uiB0 = bSPtr->signif;
-    if ( uiA0 < uiB0 ) goto copyB;
-    if ( uiB0 < uiA0 ) goto copy;
-    if ( uiA64 < uiB64 ) goto copy;
- copyB:
-    sPtr = bSPtr;
- copy:
-    zSPtr->signExp = sPtr->signExp;
-    zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by `zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    bool isSigNaNA;
+    const struct extFloat80M *sPtr;
+    bool isSigNaNB;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiMagA64, uiMagB64;
+
+    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+    sPtr = aSPtr;
+    if ( ! bSPtr ) {
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        goto copy;
+    }
+    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            uiB64 = bSPtr->signExp;
+            if ( isSigNaNB ) goto returnLargerUIMag;
+            uiB0 = bSPtr->signif;
+            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
+            goto copy;
+        } else {
+            uiA64 = aSPtr->signExp;
+            uiA0 = aSPtr->signif;
+            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
+            goto copyB;
+        }
+    }
+    uiB64 = bSPtr->signExp;
+ returnLargerUIMag:
+    uiA64 = aSPtr->signExp;
+    uiMagA64 = uiA64 & 0x7FFF;
+    uiMagB64 = uiB64 & 0x7FFF;
+    if ( uiMagA64 < uiMagB64 ) goto copyB;
+    if ( uiMagB64 < uiMagA64 ) goto copy;
+    uiA0 = aSPtr->signif;
+    uiB0 = bSPtr->signif;
+    if ( uiA0 < uiB0 ) goto copyB;
+    if ( uiB0 < uiA0 ) goto copy;
+    if ( uiA64 < uiB64 ) goto copy;
+ copyB:
+    sPtr = bSPtr;
+ copy:
+    zSPtr->signExp = sPtr->signExp;
+    zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c b/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
index cc3f0f4..fa2daae 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNExtF80UI.c
@@ -1,106 +1,106 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast64_t uiNonsigA0, uiNonsigB0;
-    uint_fast16_t uiMagA64, uiMagB64;
-    struct uint128 uiZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
-    isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
-    uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
-            goto returnA;
-        } else {
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
-            goto returnB;
-        }
-    }
- returnLargerMag:
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto returnB;
-    if ( uiMagB64 < uiMagA64 ) goto returnA;
-    if ( uiA0 < uiB0 ) goto returnB;
-    if ( uiB0 < uiA0 ) goto returnA;
-    if ( uiA64 < uiB64 ) goto returnA;
- returnB:
-    uiZ.v64 = uiB64;
-    uiZ.v0  = uiNonsigB0;
-    return uiZ;
- returnA:
-    uiZ.v64 = uiA64;
-    uiZ.v0  = uiNonsigA0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast64_t uiNonsigA0, uiNonsigB0;
+    uint_fast16_t uiMagA64, uiMagB64;
+    struct uint128 uiZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+    isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
+    uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
+            goto returnA;
+        } else {
+            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
+            goto returnB;
+        }
+    }
+ returnLargerMag:
+    uiMagA64 = uiA64 & 0x7FFF;
+    uiMagB64 = uiB64 & 0x7FFF;
+    if ( uiMagA64 < uiMagB64 ) goto returnB;
+    if ( uiMagB64 < uiMagA64 ) goto returnA;
+    if ( uiA0 < uiB0 ) goto returnB;
+    if ( uiB0 < uiA0 ) goto returnA;
+    if ( uiA64 < uiB64 ) goto returnA;
+ returnB:
+    uiZ.v64 = uiB64;
+    uiZ.v0  = uiNonsigB0;
+    return uiZ;
+ returnA:
+    uiZ.v64 = uiA64;
+    uiZ.v0  = uiNonsigA0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNF128M.c b/softfloat/source/8086-SSE/s_propagateNaNF128M.c
index aa903bf..e887274 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNF128M.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNF128M.c
@@ -1,76 +1,76 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by `zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of `aWPtr', `bWPtr',
-| and `zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-    bool isSigNaNA;
-    const uint32_t *ptr;
-
-    ptr = aWPtr;
-    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
-    if (
-        isSigNaNA
-            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto copy;
-    }
-    if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
- copy:
-    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
-    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by `zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of `aWPtr', `bWPtr',
+| and `zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+    bool isSigNaNA;
+    const uint32_t *ptr;
+
+    ptr = aWPtr;
+    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+    if (
+        isSigNaNA
+            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) goto copy;
+    }
+    if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
+ copy:
+    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNF128UI.c b/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
index 1c1c2f4..fb0e862 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNF128UI.c
@@ -1,81 +1,81 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating `uiA64' and
-| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA;
-    struct uint128 uiZ;
-
-    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
-    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto returnNonsigA;
-    }
-    if ( isNaNF128UI( uiA64, uiA0 ) ) {
- returnNonsigA:
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-    } else {
-        uiZ.v64 = uiB64;
-        uiZ.v0  = uiB0;
-    }
-    uiZ.v64 |= UINT64_C( 0x0000800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating `uiA64' and
+| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA;
+    struct uint128 uiZ;
+
+    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) goto returnNonsigA;
+    }
+    if ( isNaNF128UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+        uiZ.v64 = uiA64;
+        uiZ.v0  = uiA0;
+    } else {
+        uiZ.v64 = uiB64;
+        uiZ.v0  = uiB0;
+    }
+    uiZ.v64 |= UINT64_C( 0x0000800000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNF16UI.c b/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
index 4e87ff4..8e19e43 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNF16UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | 0x0200;
-    }
-    return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) return uiA | 0x0200;
+    }
+    return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNF32UI.c b/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
index e1a8755..6e423ca 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNF32UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | 0x00400000;
-    }
-    return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) return uiA | 0x00400000;
+    }
+    return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
+
+}
+
diff --git a/softfloat/source/8086-SSE/s_propagateNaNF64UI.c b/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
index 1af349f..474c196 100644
--- a/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
+++ b/softfloat/source/8086-SSE/s_propagateNaNF64UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
-    }
-    return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
+    }
+    return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
+
+}
+
diff --git a/softfloat/source/8086-SSE/softfloat_raiseFlags.c b/softfloat/source/8086-SSE/softfloat_raiseFlags.c
index 3115306..7a1aee9 100644
--- a/softfloat/source/8086-SSE/softfloat_raiseFlags.c
+++ b/softfloat/source/8086-SSE/softfloat_raiseFlags.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by `flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply `softfloat_exceptionFlags |= flags;'.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply `softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/softfloat/source/8086-SSE/specialize.h b/softfloat/source/8086-SSE/specialize.h
index 23b1632..8ed2e75 100644
--- a/softfloat/source/8086-SSE/specialize.h
+++ b/softfloat/source/8086-SSE/specialize.h
@@ -1,346 +1,397 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef specialize_h
-#define specialize_h 1
-
-#include "primitiveTypes.h"
-#include "softfloat.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Default value for 'softfloat_detectTininess'.
-*----------------------------------------------------------------------------*/
-#define init_detectTininess softfloat_tininess_afterRounding
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 32-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow 0xFFFFFFFF
-#define ui32_fromNegOverflow 0xFFFFFFFF
-#define ui32_fromNaN 0xFFFFFFFF
-#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNaN (-0x7FFFFFFF - 1)
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 64-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-
-/*----------------------------------------------------------------------------
-| "Common NaN" structure, used to transfer NaN representations from one format
-| to another.
-*----------------------------------------------------------------------------*/
-struct commonNaN {
-    bool sign;
-#ifdef LITTLEENDIAN
-    uint64_t v0, v64;
-#else
-    uint64_t v64, v0;
-#endif
-};
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 16-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF16UI 0xFE00
-
-/*----------------------------------------------------------------------------
-| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
-| 16-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 32-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF32UI 0xFFC00000
-
-/*----------------------------------------------------------------------------
-| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
-| 32-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 64-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
-| 64-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
-    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 80-bit extended floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNExtF80UI64 0xFFFF
-#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 80-bit unsigned integer formed from concatenating
-| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
-| floating-point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
-    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
-#define defaultNaNF128UI0 UINT64_C(0)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 128-bit unsigned integer formed from concatenating
-| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
-| point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
-    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI96 0xFFFF8000
-#define defaultNaNF128UI64 0
-#define defaultNaNF128UI32 0
-#define defaultNaNF128UI0 0
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_afterRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0xFFFFFFFF
+#define ui32_fromNaN         0xFFFFFFFF
+#define i32_fromPosOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNaN          (-0x7FFFFFFF - 1)
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define i64_fromPosOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN          (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+    bool sign;
+#ifdef LITTLEENDIAN
+    uint64_t v0, v64;
+#else
+    uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0xFE00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit brain floating-point (BF16) signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0xFFC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0xFFFF
+#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
+#define defaultNaNF128UI0  UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0xFFFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0  0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/8086/extF80M_isSignalingNaN.c b/softfloat/source/8086/extF80M_isSignalingNaN.c
index 85ee211..c2cca65 100644
--- a/softfloat/source/8086/extF80M_isSignalingNaN.c
+++ b/softfloat/source/8086/extF80M_isSignalingNaN.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint64_t uiA0;
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
-    uiA0 = aSPtr->signif;
-    return
-        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
-            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint64_t uiA0;
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+    uiA0 = aSPtr->signif;
+    return
+        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/softfloat/source/8086/f128M_isSignalingNaN.c b/softfloat/source/8086/f128M_isSignalingNaN.c
index 79a7077..9ff83d7 100644
--- a/softfloat/source/8086/f128M_isSignalingNaN.c
+++ b/softfloat/source/8086/f128M_isSignalingNaN.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool f128M_isSignalingNaN( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
-    return
-        ((uiA96 & 0x00007FFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+    return
+        ((uiA96 & 0x00007FFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToExtF80M.c b/softfloat/source/8086/s_commonNaNToExtF80M.c
index 3405b3b..06302aa 100644
--- a/softfloat/source/8086/s_commonNaNToExtF80M.c
+++ b/softfloat/source/8086/s_commonNaNToExtF80M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| `zSPtr'.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
-
-    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
-    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| `zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToExtF80UI.c b/softfloat/source/8086/s_commonNaNToExtF80UI.c
index cb7424f..7325468 100644
--- a/softfloat/source/8086/s_commonNaNToExtF80UI.c
+++ b/softfloat/source/8086/s_commonNaNToExtF80UI.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
-    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToF128M.c b/softfloat/source/8086/s_commonNaNToF128M.c
index e7ea802..e2940bb 100644
--- a/softfloat/source/8086/s_commonNaNToF128M.c
+++ b/softfloat/source/8086/s_commonNaNToF128M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
-| `zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-
-    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
-    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
+| `zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToF128UI.c b/softfloat/source/8086/s_commonNaNToF128UI.c
index 7a9423b..ac8ea7b 100644
--- a/softfloat/source/8086/s_commonNaNToF128UI.c
+++ b/softfloat/source/8086/s_commonNaNToF128UI.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
-    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToF16UI.c b/softfloat/source/8086/s_commonNaNToF16UI.c
index d4e458a..07679d7 100644
--- a/softfloat/source/8086/s_commonNaNToF16UI.c
+++ b/softfloat/source/8086/s_commonNaNToF16UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToF32UI.c b/softfloat/source/8086/s_commonNaNToF32UI.c
index ed6c226..982c1ed 100644
--- a/softfloat/source/8086/s_commonNaNToF32UI.c
+++ b/softfloat/source/8086/s_commonNaNToF32UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/softfloat/source/8086/s_commonNaNToF64UI.c b/softfloat/source/8086/s_commonNaNToF64UI.c
index 1182be3..d88c68a 100644
--- a/softfloat/source/8086/s_commonNaNToF64UI.c
+++ b/softfloat/source/8086/s_commonNaNToF64UI.c
@@ -1,53 +1,53 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
-{
-
-    return
-        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
-            | aPtr->v64>>12;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+    return
+        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+            | aPtr->v64>>12;
+
+}
+
diff --git a/softfloat/source/8086/s_extF80MToCommonNaN.c b/softfloat/source/8086/s_extF80MToCommonNaN.c
index 00baf35..6bf45cf 100644
--- a/softfloat/source/8086/s_extF80MToCommonNaN.c
+++ b/softfloat/source/8086/s_extF80MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by `zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
-{
-
-    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = signExtF80UI64( aSPtr->signExp );
-    zPtr->v64 = aSPtr->signif<<1;
-    zPtr->v0  = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by `zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = signExtF80UI64( aSPtr->signExp );
+    zPtr->v64 = aSPtr->signif<<1;
+    zPtr->v0  = 0;
+
+}
+
diff --git a/softfloat/source/8086/s_extF80UIToCommonNaN.c b/softfloat/source/8086/s_extF80UIToCommonNaN.c
index ab6311e..8b8c927 100644
--- a/softfloat/source/8086/s_extF80UIToCommonNaN.c
+++ b/softfloat/source/8086/s_extF80UIToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA64>>15;
-    zPtr->v64  = uiA0<<1;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA64>>15;
+    zPtr->v64  = uiA0<<1;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086/s_f128MToCommonNaN.c b/softfloat/source/8086/s_f128MToCommonNaN.c
index 55ec25b..2215214 100644
--- a/softfloat/source/8086/s_f128MToCommonNaN.c
+++ b/softfloat/source/8086/s_f128MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by `zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument `aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
-{
-
-    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
-    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by `zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument `aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/softfloat/source/8086/s_f128UIToCommonNaN.c b/softfloat/source/8086/s_f128UIToCommonNaN.c
index f838f02..2510c07 100644
--- a/softfloat/source/8086/s_f128UIToCommonNaN.c
+++ b/softfloat/source/8086/s_f128UIToCommonNaN.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-    struct uint128 NaNSig;
-
-    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
-    zPtr->sign = uiA64>>63;
-    zPtr->v64  = NaNSig.v64;
-    zPtr->v0   = NaNSig.v0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+    struct uint128 NaNSig;
+
+    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+    zPtr->sign = uiA64>>63;
+    zPtr->v64  = NaNSig.v64;
+    zPtr->v0   = NaNSig.v0;
+
+}
+
diff --git a/softfloat/source/8086/s_f16UIToCommonNaN.c b/softfloat/source/8086/s_f16UIToCommonNaN.c
index c1e242d..4d5003f 100644
--- a/softfloat/source/8086/s_f16UIToCommonNaN.c
+++ b/softfloat/source/8086/s_f16UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>15;
-    zPtr->v64  = (uint_fast64_t) uiA<<54;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF16UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>15;
+    zPtr->v64  = (uint_fast64_t) uiA<<54;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086/s_f32UIToCommonNaN.c b/softfloat/source/8086/s_f32UIToCommonNaN.c
index b21ba66..f4734db 100644
--- a/softfloat/source/8086/s_f32UIToCommonNaN.c
+++ b/softfloat/source/8086/s_f32UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>31;
-    zPtr->v64  = (uint_fast64_t) uiA<<41;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF32UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>31;
+    zPtr->v64  = (uint_fast64_t) uiA<<41;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086/s_f64UIToCommonNaN.c b/softfloat/source/8086/s_f64UIToCommonNaN.c
index 6529d2e..9a481a7 100644
--- a/softfloat/source/8086/s_f64UIToCommonNaN.c
+++ b/softfloat/source/8086/s_f64UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>63;
-    zPtr->v64  = uiA<<12;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF64UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>63;
+    zPtr->v64  = uiA<<12;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNExtF80M.c b/softfloat/source/8086/s_propagateNaNExtF80M.c
index ea1d57a..f35e066 100644
--- a/softfloat/source/8086/s_propagateNaNExtF80M.c
+++ b/softfloat/source/8086/s_propagateNaNExtF80M.c
@@ -1,107 +1,107 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by `zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    bool isSigNaNA;
-    const struct extFloat80M *sPtr;
-    bool isSigNaNB;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiMagA64, uiMagB64;
-
-    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
-    sPtr = aSPtr;
-    if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
-        goto copy;
-    }
-    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            uiB64 = bSPtr->signExp;
-            if ( isSigNaNB ) goto returnLargerUIMag;
-            uiB0 = bSPtr->signif;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
-            goto copy;
-        } else {
-            uiA64 = aSPtr->signExp;
-            uiA0 = aSPtr->signif;
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
-            goto copyB;
-        }
-    }
-    uiB64 = bSPtr->signExp;
- returnLargerUIMag:
-    uiA64 = aSPtr->signExp;
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto copyB;
-    if ( uiMagB64 < uiMagA64 ) goto copy;
-    uiA0 = aSPtr->signif;
-    uiB0 = bSPtr->signif;
-    if ( uiA0 < uiB0 ) goto copyB;
-    if ( uiB0 < uiA0 ) goto copy;
-    if ( uiA64 < uiB64 ) goto copy;
- copyB:
-    sPtr = bSPtr;
- copy:
-    zSPtr->signExp = sPtr->signExp;
-    zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by `zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    bool isSigNaNA;
+    const struct extFloat80M *sPtr;
+    bool isSigNaNB;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiMagA64, uiMagB64;
+
+    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+    sPtr = aSPtr;
+    if ( ! bSPtr ) {
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        goto copy;
+    }
+    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            uiB64 = bSPtr->signExp;
+            if ( isSigNaNB ) goto returnLargerUIMag;
+            uiB0 = bSPtr->signif;
+            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
+            goto copy;
+        } else {
+            uiA64 = aSPtr->signExp;
+            uiA0 = aSPtr->signif;
+            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
+            goto copyB;
+        }
+    }
+    uiB64 = bSPtr->signExp;
+ returnLargerUIMag:
+    uiA64 = aSPtr->signExp;
+    uiMagA64 = uiA64 & 0x7FFF;
+    uiMagB64 = uiB64 & 0x7FFF;
+    if ( uiMagA64 < uiMagB64 ) goto copyB;
+    if ( uiMagB64 < uiMagA64 ) goto copy;
+    uiA0 = aSPtr->signif;
+    uiB0 = bSPtr->signif;
+    if ( uiA0 < uiB0 ) goto copyB;
+    if ( uiB0 < uiA0 ) goto copy;
+    if ( uiA64 < uiB64 ) goto copy;
+ copyB:
+    sPtr = bSPtr;
+ copy:
+    zSPtr->signExp = sPtr->signExp;
+    zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNExtF80UI.c b/softfloat/source/8086/s_propagateNaNExtF80UI.c
index cc3f0f4..fa2daae 100644
--- a/softfloat/source/8086/s_propagateNaNExtF80UI.c
+++ b/softfloat/source/8086/s_propagateNaNExtF80UI.c
@@ -1,106 +1,106 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast64_t uiNonsigA0, uiNonsigB0;
-    uint_fast16_t uiMagA64, uiMagB64;
-    struct uint128 uiZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
-    isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
-    uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
-            goto returnA;
-        } else {
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
-            goto returnB;
-        }
-    }
- returnLargerMag:
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto returnB;
-    if ( uiMagB64 < uiMagA64 ) goto returnA;
-    if ( uiA0 < uiB0 ) goto returnB;
-    if ( uiB0 < uiA0 ) goto returnA;
-    if ( uiA64 < uiB64 ) goto returnA;
- returnB:
-    uiZ.v64 = uiB64;
-    uiZ.v0  = uiNonsigB0;
-    return uiZ;
- returnA:
-    uiZ.v64 = uiA64;
-    uiZ.v0  = uiNonsigA0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast64_t uiNonsigA0, uiNonsigB0;
+    uint_fast16_t uiMagA64, uiMagB64;
+    struct uint128 uiZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+    isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
+    uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
+            goto returnA;
+        } else {
+            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
+            goto returnB;
+        }
+    }
+ returnLargerMag:
+    uiMagA64 = uiA64 & 0x7FFF;
+    uiMagB64 = uiB64 & 0x7FFF;
+    if ( uiMagA64 < uiMagB64 ) goto returnB;
+    if ( uiMagB64 < uiMagA64 ) goto returnA;
+    if ( uiA0 < uiB0 ) goto returnB;
+    if ( uiB0 < uiA0 ) goto returnA;
+    if ( uiA64 < uiB64 ) goto returnA;
+ returnB:
+    uiZ.v64 = uiB64;
+    uiZ.v0  = uiNonsigB0;
+    return uiZ;
+ returnA:
+    uiZ.v64 = uiA64;
+    uiZ.v0  = uiNonsigA0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNF128M.c b/softfloat/source/8086/s_propagateNaNF128M.c
index 06554fb..7ac2e5f 100644
--- a/softfloat/source/8086/s_propagateNaNF128M.c
+++ b/softfloat/source/8086/s_propagateNaNF128M.c
@@ -1,108 +1,108 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by `zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of `aWPtr', `bWPtr',
-| and `zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-    bool isSigNaNA;
-    const uint32_t *ptr;
-    bool isSigNaNB;
-    uint32_t uiA96, uiB96, wordMagA, wordMagB;
-
-    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
-    ptr = aWPtr;
-    if ( ! bWPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
-        goto copy;
-    }
-    isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerUIMag;
-            if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
-            goto copy;
-        } else {
-            if ( softfloat_isNaNF128M( aWPtr ) ) goto copy;
-            goto copyB;
-        }
-    }
- returnLargerUIMag:
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    wordMagA = uiA96 & 0x7FFFFFFF;
-    wordMagB = uiB96 & 0x7FFFFFFF;
-    if ( wordMagA < wordMagB ) goto copyB;
-    if ( wordMagB < wordMagA ) goto copy;
-    wordMagA = aWPtr[indexWord( 4, 2 )];
-    wordMagB = bWPtr[indexWord( 4, 2 )];
-    if ( wordMagA < wordMagB ) goto copyB;
-    if ( wordMagB < wordMagA ) goto copy;
-    wordMagA = aWPtr[indexWord( 4, 1 )];
-    wordMagB = bWPtr[indexWord( 4, 1 )];
-    if ( wordMagA < wordMagB ) goto copyB;
-    if ( wordMagB < wordMagA ) goto copy;
-    wordMagA = aWPtr[indexWord( 4, 0 )];
-    wordMagB = bWPtr[indexWord( 4, 0 )];
-    if ( wordMagA < wordMagB ) goto copyB;
-    if ( wordMagB < wordMagA ) goto copy;
-    if ( uiA96 < uiB96 ) goto copy;
- copyB:
-    ptr = bWPtr;
- copy:
-    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
-    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by `zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of `aWPtr', `bWPtr',
+| and `zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+    bool isSigNaNA;
+    const uint32_t *ptr;
+    bool isSigNaNB;
+    uint32_t uiA96, uiB96, wordMagA, wordMagB;
+
+    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+    ptr = aWPtr;
+    if ( ! bWPtr ) {
+        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
+        goto copy;
+    }
+    isSigNaNB = f128M_isSignalingNaN( (const float128_t *) bWPtr );
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerUIMag;
+            if ( softfloat_isNaNF128M( bWPtr ) ) goto copyB;
+            goto copy;
+        } else {
+            if ( softfloat_isNaNF128M( aWPtr ) ) goto copy;
+            goto copyB;
+        }
+    }
+ returnLargerUIMag:
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    wordMagA = uiA96 & 0x7FFFFFFF;
+    wordMagB = uiB96 & 0x7FFFFFFF;
+    if ( wordMagA < wordMagB ) goto copyB;
+    if ( wordMagB < wordMagA ) goto copy;
+    wordMagA = aWPtr[indexWord( 4, 2 )];
+    wordMagB = bWPtr[indexWord( 4, 2 )];
+    if ( wordMagA < wordMagB ) goto copyB;
+    if ( wordMagB < wordMagA ) goto copy;
+    wordMagA = aWPtr[indexWord( 4, 1 )];
+    wordMagB = bWPtr[indexWord( 4, 1 )];
+    if ( wordMagA < wordMagB ) goto copyB;
+    if ( wordMagB < wordMagA ) goto copy;
+    wordMagA = aWPtr[indexWord( 4, 0 )];
+    wordMagB = bWPtr[indexWord( 4, 0 )];
+    if ( wordMagA < wordMagB ) goto copyB;
+    if ( wordMagB < wordMagA ) goto copy;
+    if ( uiA96 < uiB96 ) goto copy;
+ copyB:
+    ptr = bWPtr;
+ copy:
+    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNF128UI.c b/softfloat/source/8086/s_propagateNaNF128UI.c
index 46b9f5f..6caecd2 100644
--- a/softfloat/source/8086/s_propagateNaNF128UI.c
+++ b/softfloat/source/8086/s_propagateNaNF128UI.c
@@ -1,105 +1,105 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64;
-    struct uint128 uiZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
-    isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 );
-    uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
-            goto returnA;
-        } else {
-            if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA;
-            goto returnB;
-        }
-    }
- returnLargerMag:
-    uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-    uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-    if ( uiMagA64 < uiMagB64 ) goto returnB;
-    if ( uiMagB64 < uiMagA64 ) goto returnA;
-    if ( uiA0 < uiB0 ) goto returnB;
-    if ( uiB0 < uiA0 ) goto returnA;
-    if ( uiNonsigA64 < uiNonsigB64 ) goto returnA;
- returnB:
-    uiZ.v64 = uiNonsigB64;
-    uiZ.v0  = uiB0;
-    return uiZ;
- returnA:
-    uiZ.v64 = uiNonsigA64;
-    uiZ.v0  = uiA0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast64_t uiNonsigA64, uiNonsigB64, uiMagA64, uiMagB64;
+    struct uint128 uiZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+    isSigNaNB = softfloat_isSigNaNF128UI( uiB64, uiB0 );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA64 = uiA64 | UINT64_C( 0x0000800000000000 );
+    uiNonsigB64 = uiB64 | UINT64_C( 0x0000800000000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            if ( isNaNF128UI( uiB64, uiB0 ) ) goto returnB;
+            goto returnA;
+        } else {
+            if ( isNaNF128UI( uiA64, uiA0 ) ) goto returnA;
+            goto returnB;
+        }
+    }
+ returnLargerMag:
+    uiMagA64 = uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+    uiMagB64 = uiB64 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+    if ( uiMagA64 < uiMagB64 ) goto returnB;
+    if ( uiMagB64 < uiMagA64 ) goto returnA;
+    if ( uiA0 < uiB0 ) goto returnB;
+    if ( uiB0 < uiA0 ) goto returnA;
+    if ( uiNonsigA64 < uiNonsigB64 ) goto returnA;
+ returnB:
+    uiZ.v64 = uiNonsigB64;
+    uiZ.v0  = uiB0;
+    return uiZ;
+ returnA:
+    uiZ.v64 = uiNonsigA64;
+    uiZ.v0  = uiA0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNF16UI.c b/softfloat/source/8086/s_propagateNaNF16UI.c
index 89cc0fe..f9d80d6 100644
--- a/softfloat/source/8086/s_propagateNaNF16UI.c
+++ b/softfloat/source/8086/s_propagateNaNF16UI.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
-    isSigNaNB = softfloat_isSigNaNF16UI( uiB );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA = uiA | 0x0200;
-    uiNonsigB = uiB | 0x0200;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
-        } else {
-            return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB;
-        }
-    }
- returnLargerMag:
-    uiMagA = uiA & 0x7FFF;
-    uiMagB = uiB & 0x7FFF;
-    if ( uiMagA < uiMagB ) return uiNonsigB;
-    if ( uiMagB < uiMagA ) return uiNonsigA;
-    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast16_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+    isSigNaNB = softfloat_isSigNaNF16UI( uiB );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA = uiA | 0x0200;
+    uiNonsigB = uiB | 0x0200;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            return isNaNF16UI( uiB ) ? uiNonsigB : uiNonsigA;
+        } else {
+            return isNaNF16UI( uiA ) ? uiNonsigA : uiNonsigB;
+        }
+    }
+ returnLargerMag:
+    uiMagA = uiA & 0x7FFF;
+    uiMagB = uiB & 0x7FFF;
+    if ( uiMagA < uiMagB ) return uiNonsigB;
+    if ( uiMagB < uiMagA ) return uiNonsigA;
+    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNF32UI.c b/softfloat/source/8086/s_propagateNaNF32UI.c
index aeb6024..2350ad7 100644
--- a/softfloat/source/8086/s_propagateNaNF32UI.c
+++ b/softfloat/source/8086/s_propagateNaNF32UI.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
-    isSigNaNB = softfloat_isSigNaNF32UI( uiB );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA = uiA | 0x00400000;
-    uiNonsigB = uiB | 0x00400000;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
-        } else {
-            return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB;
-        }
-    }
- returnLargerMag:
-    uiMagA = uiA & 0x7FFFFFFF;
-    uiMagB = uiB & 0x7FFFFFFF;
-    if ( uiMagA < uiMagB ) return uiNonsigB;
-    if ( uiMagB < uiMagA ) return uiNonsigA;
-    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast32_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+    isSigNaNB = softfloat_isSigNaNF32UI( uiB );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA = uiA | 0x00400000;
+    uiNonsigB = uiB | 0x00400000;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            return isNaNF32UI( uiB ) ? uiNonsigB : uiNonsigA;
+        } else {
+            return isNaNF32UI( uiA ) ? uiNonsigA : uiNonsigB;
+        }
+    }
+ returnLargerMag:
+    uiMagA = uiA & 0x7FFFFFFF;
+    uiMagB = uiB & 0x7FFFFFFF;
+    if ( uiMagA < uiMagB ) return uiNonsigB;
+    if ( uiMagB < uiMagA ) return uiNonsigA;
+    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/softfloat/source/8086/s_propagateNaNF64UI.c b/softfloat/source/8086/s_propagateNaNF64UI.c
index dabad40..a4013d4 100644
--- a/softfloat/source/8086/s_propagateNaNF64UI.c
+++ b/softfloat/source/8086/s_propagateNaNF64UI.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
-    isSigNaNB = softfloat_isSigNaNF64UI( uiB );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA = uiA | UINT64_C( 0x0008000000000000 );
-    uiNonsigB = uiB | UINT64_C( 0x0008000000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
-        } else {
-            return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB;
-        }
-    }
- returnLargerMag:
-    uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-    uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-    if ( uiMagA < uiMagB ) return uiNonsigB;
-    if ( uiMagB < uiMagA ) return uiNonsigA;
-    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+    bool isSigNaNA, isSigNaNB;
+    uint_fast64_t uiNonsigA, uiNonsigB, uiMagA, uiMagB;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+    isSigNaNB = softfloat_isSigNaNF64UI( uiB );
+    /*------------------------------------------------------------------------
+    | Make NaNs non-signaling.
+    *------------------------------------------------------------------------*/
+    uiNonsigA = uiA | UINT64_C( 0x0008000000000000 );
+    uiNonsigB = uiB | UINT64_C( 0x0008000000000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isSigNaNA | isSigNaNB ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) {
+            if ( isSigNaNB ) goto returnLargerMag;
+            return isNaNF64UI( uiB ) ? uiNonsigB : uiNonsigA;
+        } else {
+            return isNaNF64UI( uiA ) ? uiNonsigA : uiNonsigB;
+        }
+    }
+ returnLargerMag:
+    uiMagA = uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+    uiMagB = uiB & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+    if ( uiMagA < uiMagB ) return uiNonsigB;
+    if ( uiMagB < uiMagA ) return uiNonsigA;
+    return (uiNonsigA < uiNonsigB) ? uiNonsigA : uiNonsigB;
+
+}
+
diff --git a/softfloat/source/8086/softfloat_raiseFlags.c b/softfloat/source/8086/softfloat_raiseFlags.c
index 3115306..7a1aee9 100644
--- a/softfloat/source/8086/softfloat_raiseFlags.c
+++ b/softfloat/source/8086/softfloat_raiseFlags.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by `flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply `softfloat_exceptionFlags |= flags;'.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply `softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/softfloat/source/8086/specialize.h b/softfloat/source/8086/specialize.h
index 23b1632..a9166e1 100644
--- a/softfloat/source/8086/specialize.h
+++ b/softfloat/source/8086/specialize.h
@@ -1,346 +1,376 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef specialize_h
-#define specialize_h 1
-
-#include "primitiveTypes.h"
-#include "softfloat.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Default value for 'softfloat_detectTininess'.
-*----------------------------------------------------------------------------*/
-#define init_detectTininess softfloat_tininess_afterRounding
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 32-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow 0xFFFFFFFF
-#define ui32_fromNegOverflow 0xFFFFFFFF
-#define ui32_fromNaN 0xFFFFFFFF
-#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNaN (-0x7FFFFFFF - 1)
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 64-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-
-/*----------------------------------------------------------------------------
-| "Common NaN" structure, used to transfer NaN representations from one format
-| to another.
-*----------------------------------------------------------------------------*/
-struct commonNaN {
-    bool sign;
-#ifdef LITTLEENDIAN
-    uint64_t v0, v64;
-#else
-    uint64_t v64, v0;
-#endif
-};
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 16-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF16UI 0xFE00
-
-/*----------------------------------------------------------------------------
-| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
-| 16-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 32-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF32UI 0xFFC00000
-
-/*----------------------------------------------------------------------------
-| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
-| 32-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 64-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
-| 64-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
-    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 80-bit extended floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNExtF80UI64 0xFFFF
-#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 80-bit unsigned integer formed from concatenating
-| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
-| floating-point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
-    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
-#define defaultNaNF128UI0 UINT64_C(0)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 128-bit unsigned integer formed from concatenating
-| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
-| point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
-    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI96 0xFFFF8000
-#define defaultNaNF128UI64 0
-#define defaultNaNF128UI32 0
-#define defaultNaNF128UI0 0
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_afterRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0xFFFFFFFF
+#define ui32_fromNaN         0xFFFFFFFF
+#define i32_fromPosOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNaN          (-0x7FFFFFFF - 1)
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define i64_fromPosOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN          (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+    bool sign;
+#ifdef LITTLEENDIAN
+    uint64_t v0, v64;
+#else
+    uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0xFE00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0xFFC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0xFFFF
+#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
+#define defaultNaNF128UI0  UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0xFFFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0  0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
index 85ee211..c2cca65 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/extF80M_isSignalingNaN.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint64_t uiA0;
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
-    uiA0 = aSPtr->signif;
-    return
-        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
-            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint64_t uiA0;
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+    uiA0 = aSPtr->signif;
+    return
+        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
index 79a7077..9ff83d7 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/f128M_isSignalingNaN.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool f128M_isSignalingNaN( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
-    return
-        ((uiA96 & 0x00007FFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+    return
+        ((uiA96 & 0x00007FFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
index 54a50dc..2e6bf7c 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80M.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat_types.h"
-
-#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
-
-    zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif  = defaultNaNExtF80UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat_types.h"
+
+#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
index 5b698f6..e37004f 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToExtF80UI.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = defaultNaNExtF80UI64;
-    uiZ.v0  = defaultNaNExtF80UI0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
index b22baa8..2ff4c16 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128M.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-
-    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
-    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
-    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
-    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
index 70f0cf1..05dfb5f 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF128UI.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF16UI.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF32UI.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_commonNaNToF64UI.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80MToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_extF80UIToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_f128MToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_f128UIToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_f16UIToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_f32UIToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
index 7c7d5c8..861b269 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_f64UIToCommonNaN.c
@@ -1,5 +1,5 @@
-
-/*----------------------------------------------------------------------------
-| This file intentionally contains no code.
-*----------------------------------------------------------------------------*/
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
index 1c6510c..827ed5e 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80M.c
@@ -1,74 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    uint_fast16_t ui64;
-    uint_fast64_t ui0;
-
-    ui64 = aSPtr->signExp;
-    ui0  = aSPtr->signif;
-    if (
-        softfloat_isSigNaNExtF80UI( ui64, ui0 )
-            || (bSPtr
-                    && (ui64 = bSPtr->signExp,
-                        ui0  = bSPtr->signif,
-                        softfloat_isSigNaNExtF80UI( ui64, ui0 )))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif  = defaultNaNExtF80UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    uint_fast16_t ui64;
+    uint_fast64_t ui0;
+
+    ui64 = aSPtr->signExp;
+    ui0  = aSPtr->signif;
+    if (
+        softfloat_isSigNaNExtF80UI( ui64, ui0 )
+            || (bSPtr
+                    && (ui64 = bSPtr->signExp,
+                        ui0  = bSPtr->signif,
+                        softfloat_isSigNaNExtF80UI( ui64, ui0 )))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
index e1bb155..e2ddd93 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNExtF80UI.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    struct uint128 uiZ;
-
-    if (
-           softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-        || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    uiZ.v64 = defaultNaNExtF80UI64;
-    uiZ.v0  = defaultNaNExtF80UI0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    struct uint128 uiZ;
+
+    if (
+           softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+        || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
index 9bddee9..b876ae1 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128M.c
@@ -1,68 +1,68 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-
-    if (
-        f128M_isSignalingNaN( (const float128_t *) aWPtr );
-            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
-    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
-    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
-    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+
+    if (
+        f128M_isSignalingNaN( (const float128_t *) aWPtr );
+            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
index 57fddd1..31b788e 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF128UI.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    struct uint128 uiZ;
-
-    if (
-           softfloat_isSigNaNF128UI( uiA64, uiA0 )
-        || softfloat_isSigNaNF128UI( uiB64, uiB0 )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    struct uint128 uiZ;
+
+    if (
+           softfloat_isSigNaNF128UI( uiA64, uiA0 )
+        || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
index 0b08e00..17618fc 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF16UI.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-
-    if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    return defaultNaNF16UI;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+
+    if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF16UI;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
index cab7403..e4c3fc1 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF32UI.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-
-    if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    return defaultNaNF32UI;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+
+    if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF32UI;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
index 83b91d3..75361b8 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/s_propagateNaNF64UI.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-
-    if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    return defaultNaNF64UI;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+
+    if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF64UI;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c b/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
index 61046da..f8f1065 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/softfloat_raiseFlags.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by 'flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply 'softfloat_exceptionFlags |= flags;'.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by 'flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply 'softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h b/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
index 9d8e569..e4ea15d 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
@@ -1,393 +1,407 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef specialize_h
-#define specialize_h 1
-
-#include "primitiveTypes.h"
-#include "softfloat.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Default value for 'softfloat_detectTininess'.
-*----------------------------------------------------------------------------*/
-#define init_detectTininess softfloat_tininess_beforeRounding
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 32-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow 0xFFFFFFFF
-#define ui32_fromNegOverflow 0
-#define ui32_fromNaN 0
-#define i32_fromPosOverflow 0x7FFFFFFF
-#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNaN 0
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 64-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNegOverflow 0
-#define ui64_fromNaN 0
-#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
-#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNaN 0
-
-/*----------------------------------------------------------------------------
-| "Common NaN" structure, used to transfer NaN representations from one format
-| to another.
-*----------------------------------------------------------------------------*/
-struct commonNaN {
-    char _unused;
-};
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 16-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF16UI 0x7E00
-
-/*----------------------------------------------------------------------------
-| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
-| 16-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_f16UIToCommonNaN(uiA, zPtr)                                                                                              \
-    if(!((uiA)&0x0200))                                                                                                                    \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF16UI(aPtr) ((uint_fast16_t)defaultNaNF16UI)
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 32-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF32UI 0x7FC00000
-
-/*----------------------------------------------------------------------------
-| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
-| 32-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_f32UIToCommonNaN(uiA, zPtr)                                                                                              \
-    if(!((uiA)&0x00400000))                                                                                                                \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF32UI(aPtr) ((uint_fast32_t)defaultNaNF32UI)
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 64-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
-| 64-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
-    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_f64UIToCommonNaN(uiA, zPtr)                                                                                              \
-    if(!((uiA)&UINT64_C(0x0008000000000000)))                                                                                              \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF64UI(aPtr) ((uint_fast64_t)defaultNaNF64UI)
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 80-bit extended floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNExtF80UI64 0x7FFF
-#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 80-bit unsigned integer formed from concatenating
-| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
-| floating-point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
-    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_extF80UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                   \
-    if(!((uiA0)&UINT64_C(0x4000000000000000)))                                                                                             \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-#if defined INLINE && !defined softfloat_commonNaNToExtF80UI
-INLINE
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr) {
-    struct uint128 uiZ;
-    uiZ.v64 = defaultNaNExtF80UI64;
-    uiZ.v0 = defaultNaNExtF80UI0;
-    return uiZ;
-}
-#else
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
-#endif
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
-#define defaultNaNF128UI0 UINT64_C(0)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 128-bit unsigned integer formed from concatenating
-| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
-| point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
-    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_f128UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                     \
-    if(!((uiA64)&UINT64_C(0x0000800000000000)))                                                                                            \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-#if defined INLINE && !defined softfloat_commonNaNToF128UI
-INLINE
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN* aPtr) {
-    struct uint128 uiZ;
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0 = defaultNaNF128UI0;
-    return uiZ;
-}
-#else
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
-#endif
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-#define softfloat_extF80MToCommonNaN(aSPtr, zPtr)                                                                                          \
-    if(!((aSPtr)->signif & UINT64_C(0x4000000000000000)))                                                                                  \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE && !defined softfloat_commonNaNToExtF80M
-INLINE
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr) {
-    zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif = defaultNaNExtF80UI0;
-}
-#else
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
-#endif
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI96 0x7FFF8000
-#define defaultNaNF128UI64 0
-#define defaultNaNF128UI32 0
-#define defaultNaNF128UI0 0
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-#define softfloat_f128MToCommonNaN(aWPtr, zPtr)                                                                                            \
-    if(!((aWPtr)[indexWordHi(4)] & UINT64_C(0x0000800000000000)))                                                                          \
-    softfloat_raiseFlags(softfloat_flag_invalid)
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-#if defined INLINE && !defined softfloat_commonNaNToF128M
-INLINE
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr) {
-    zWPtr[indexWord(4, 3)] = defaultNaNF128UI96;
-    zWPtr[indexWord(4, 2)] = defaultNaNF128UI64;
-    zWPtr[indexWord(4, 1)] = defaultNaNF128UI32;
-    zWPtr[indexWord(4, 0)] = defaultNaNF128UI0;
-}
-#else
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
-#endif
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_beforeRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0
+#define ui32_fromNaN         0
+#define i32_fromPosOverflow  0x7FFFFFFF
+#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNaN          0
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow 0
+#define ui64_fromNaN         0
+#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN          0
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN { char _unused; };
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0x7E00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0x7FC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0x7FFF
+#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
+INLINE
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
+#define defaultNaNF128UI0  UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128UI
+INLINE
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
+INLINE
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+}
+#else
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0x7FFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0  0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128M
+INLINE
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+}
+#else
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c b/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
index 85ee211..c2cca65 100644
--- a/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
+++ b/softfloat/source/ARM-VFPv2/extF80M_isSignalingNaN.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint64_t uiA0;
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
-    uiA0 = aSPtr->signif;
-    return
-        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
-            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint64_t uiA0;
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+    uiA0 = aSPtr->signif;
+    return
+        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c b/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
index 79a7077..9ff83d7 100644
--- a/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
+++ b/softfloat/source/ARM-VFPv2/f128M_isSignalingNaN.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool f128M_isSignalingNaN( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
-    return
-        ((uiA96 & 0x00007FFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+    return
+        ((uiA96 & 0x00007FFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c b/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
index 543400b..6bb922a 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
-
-    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
-    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
+    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c b/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
index 6cf1d11..5e841b2 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToExtF80UI.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
-    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
+    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c b/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
index 4e8ede0..02e2348 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToF128M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-
-    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
-    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
+    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c b/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
index f938c3f..fa87d75 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToF128UI.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
-    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
+    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c b/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
index 6cd4fc1..6d5bf9a 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToF16UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c b/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
index 7b38167..e45d63b 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToF32UI.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
+{
+
+    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c b/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
index 1484702..bfde88b 100644
--- a/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
+++ b/softfloat/source/ARM-VFPv2/s_commonNaNToF64UI.c
@@ -1,53 +1,53 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
-{
-
-    return
-        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
-            | aPtr->v64>>12;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
+{
+
+    return
+        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
+            | aPtr->v64>>12;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
index 82216cf..5fd54db 100644
--- a/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_extF80MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
-{
-
-    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = signExtF80UI64( aSPtr->signExp );
-    zPtr->v64 = aSPtr->signif<<1;
-    zPtr->v0  = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
+{
+
+    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = signExtF80UI64( aSPtr->signExp );
+    zPtr->v64 = aSPtr->signif<<1;
+    zPtr->v0  = 0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
index 2559fb6..9c0f0ca 100644
--- a/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_extF80UIToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA64>>15;
-    zPtr->v64  = uiA0<<1;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA64>>15;
+    zPtr->v64  = uiA0<<1;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
index 322d25a..e54756b 100644
--- a/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_f128MToCommonNaN.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
-{
-
-    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
-    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
+{
+
+    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
+    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
index 843c187..27952a7 100644
--- a/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_f128UIToCommonNaN.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-    struct uint128 NaNSig;
-
-    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
-    zPtr->sign = uiA64>>63;
-    zPtr->v64  = NaNSig.v64;
-    zPtr->v0   = NaNSig.v0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
+{
+    struct uint128 NaNSig;
+
+    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
+    zPtr->sign = uiA64>>63;
+    zPtr->v64  = NaNSig.v64;
+    zPtr->v0   = NaNSig.v0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
index f5fe587..ee1928e 100644
--- a/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_f16UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>15;
-    zPtr->v64  = (uint_fast64_t) uiA<<54;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF16UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>15;
+    zPtr->v64  = (uint_fast64_t) uiA<<54;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
index 58726a3..249e478 100644
--- a/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_f32UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>31;
-    zPtr->v64  = (uint_fast64_t) uiA<<41;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF32UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>31;
+    zPtr->v64  = (uint_fast64_t) uiA<<41;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c b/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
index 03761e4..adca2d0 100644
--- a/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
+++ b/softfloat/source/ARM-VFPv2/s_f64UIToCommonNaN.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>63;
-    zPtr->v64  = uiA<<12;
-    zPtr->v0   = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
+{
+
+    if ( softfloat_isSigNaNF64UI( uiA ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zPtr->sign = uiA>>63;
+    zPtr->v64  = uiA<<12;
+    zPtr->v0   = 0;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c b/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
index f10ed0b..1c14256 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80M.c
@@ -1,86 +1,86 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    const struct extFloat80M *sPtr;
-    bool isSigNaNA;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-
-    sPtr = aSPtr;
-    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
-    if (
-        isSigNaNA
-            || (bSPtr
-                    && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto copyNonsig;
-        goto copyNonsigB;
-    }
-    uiZ64 = sPtr->signExp;
-    uiZ0  = sPtr->signif;
-    if ( isNaNExtF80UI( uiZ64, uiZ0 ) ) goto returnNonsig;
- copyNonsigB:
-    sPtr = bSPtr;
- copyNonsig:
-    uiZ64 = sPtr->signExp;
-    uiZ0  = sPtr->signif;
- returnNonsig:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = uiZ0 | UINT64_C( 0xC000000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    const struct extFloat80M *sPtr;
+    bool isSigNaNA;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+
+    sPtr = aSPtr;
+    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
+    if (
+        isSigNaNA
+            || (bSPtr
+                    && extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr ))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) goto copyNonsig;
+        goto copyNonsigB;
+    }
+    uiZ64 = sPtr->signExp;
+    uiZ0  = sPtr->signif;
+    if ( isNaNExtF80UI( uiZ64, uiZ0 ) ) goto returnNonsig;
+ copyNonsigB:
+    sPtr = bSPtr;
+ copyNonsig:
+    uiZ64 = sPtr->signExp;
+    uiZ0  = sPtr->signif;
+ returnNonsig:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = uiZ0 | UINT64_C( 0xC000000000000000 );
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c b/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
index bd23c24..be95414 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNExtF80UI.c
@@ -1,83 +1,83 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA;
-    struct uint128 uiZ;
-
-    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
-    if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto returnNonsigA;
-        goto returnNonsigB;
-    }
-    if ( isNaNExtF80UI( uiA64, uiA0 ) ) {
- returnNonsigA:
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-    } else {
- returnNonsigB:
-        uiZ.v64 = uiB64;
-        uiZ.v0  = uiB0;
-    }
-    uiZ.v0 | UINT64_C( 0xC000000000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA;
+    struct uint128 uiZ;
+
+    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
+    if ( isSigNaNA || softfloat_isSigNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) goto returnNonsigA;
+        goto returnNonsigB;
+    }
+    if ( isNaNExtF80UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+        uiZ.v64 = uiA64;
+        uiZ.v0  = uiA0;
+    } else {
+ returnNonsigB:
+        uiZ.v64 = uiB64;
+        uiZ.v0  = uiB0;
+    }
+    uiZ.v0 | UINT64_C( 0xC000000000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c b/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
index 23e766a..6a30052 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNF128M.c
@@ -1,77 +1,77 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-    const uint32_t *ptr;
-    bool isSigNaNA;
-
-    ptr = aWPtr;
-    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
-    if (
-        isSigNaNA
-            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( ! isSigNaNA ) ptr = bWPtr;
-        goto copyNonsig;
-    }
-    if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
- copyNonsig:
-    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
-    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+    const uint32_t *ptr;
+    bool isSigNaNA;
+
+    ptr = aWPtr;
+    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
+    if (
+        isSigNaNA
+            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( ! isSigNaNA ) ptr = bWPtr;
+        goto copyNonsig;
+    }
+    if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
+ copyNonsig:
+    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
+    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c b/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
index b8882d7..5aece62 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNF128UI.c
@@ -1,83 +1,83 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA;
-    struct uint128 uiZ;
-
-    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
-    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto returnNonsigA;
-        goto returnNonsigB;
-    }
-    if ( isNaNF128UI( uiA64, uiA0 ) ) {
- returnNonsigA:
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-    } else {
- returnNonsigB:
-        uiZ.v64 = uiB64;
-        uiZ.v0  = uiB0;
-    }
-    uiZ.v64 |= UINT64_C( 0x0000800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    bool isSigNaNA;
+    struct uint128 uiZ;
+
+    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
+    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        if ( isSigNaNA ) goto returnNonsigA;
+        goto returnNonsigB;
+    }
+    if ( isNaNF128UI( uiA64, uiA0 ) ) {
+ returnNonsigA:
+        uiZ.v64 = uiA64;
+        uiZ.v0  = uiA0;
+    } else {
+ returnNonsigB:
+        uiZ.v64 = uiB64;
+        uiZ.v0  = uiB0;
+    }
+    uiZ.v64 |= UINT64_C( 0x0000800000000000 );
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c b/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
index e333328..8801460 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNF16UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return (isSigNaNA ? uiA : uiB) | 0x0200;
-    }
-    return isNaNF16UI( uiA ) ? uiA : uiB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return (isSigNaNA ? uiA : uiB) | 0x0200;
+    }
+    return isNaNF16UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c b/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
index c7508ae..31b289e 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNF32UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return (isSigNaNA ? uiA : uiB) | 0x00400000;
-    }
-    return isNaNF32UI( uiA ) ? uiA : uiB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return (isSigNaNA ? uiA : uiB) | 0x00400000;
+    }
+    return isNaNF32UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c b/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
index 8c67763..224049a 100644
--- a/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
+++ b/softfloat/source/ARM-VFPv2/s_propagateNaNF64UI.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
-    }
-    return isNaNF64UI( uiA ) ? uiA : uiB;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+    bool isSigNaNA;
+
+    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
+    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return (isSigNaNA ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
+    }
+    return isNaNF64UI( uiA ) ? uiA : uiB;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c b/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
index 61046da..f8f1065 100644
--- a/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
+++ b/softfloat/source/ARM-VFPv2/softfloat_raiseFlags.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by 'flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply 'softfloat_exceptionFlags |= flags;'.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by 'flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply 'softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/softfloat/source/ARM-VFPv2/specialize.h b/softfloat/source/ARM-VFPv2/specialize.h
index 638e690..10b0b35 100644
--- a/softfloat/source/ARM-VFPv2/specialize.h
+++ b/softfloat/source/ARM-VFPv2/specialize.h
@@ -1,346 +1,376 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef specialize_h
-#define specialize_h 1
-
-#include "primitiveTypes.h"
-#include "softfloat.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Default value for 'softfloat_detectTininess'.
-*----------------------------------------------------------------------------*/
-#define init_detectTininess softfloat_tininess_beforeRounding
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 32-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow 0xFFFFFFFF
-#define ui32_fromNegOverflow 0
-#define ui32_fromNaN 0
-#define i32_fromPosOverflow 0x7FFFFFFF
-#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
-#define i32_fromNaN 0
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 64-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNegOverflow 0
-#define ui64_fromNaN 0
-#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
-#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNaN 0
-
-/*----------------------------------------------------------------------------
-| "Common NaN" structure, used to transfer NaN representations from one format
-| to another.
-*----------------------------------------------------------------------------*/
-struct commonNaN {
-    bool sign;
-#ifdef LITTLEENDIAN
-    uint64_t v0, v64;
-#else
-    uint64_t v64, v0;
-#endif
-};
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 16-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF16UI 0x7E00
-
-/*----------------------------------------------------------------------------
-| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
-| 16-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 32-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF32UI 0x7FC00000
-
-/*----------------------------------------------------------------------------
-| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
-| 32-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 64-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
-| 64-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
-    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 80-bit extended floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNExtF80UI64 0x7FFF
-#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 80-bit unsigned integer formed from concatenating
-| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
-| floating-point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
-    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
-#define defaultNaNF128UI0 UINT64_C(0)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 128-bit unsigned integer formed from concatenating
-| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
-| point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
-    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI96 0x7FFF8000
-#define defaultNaNF128UI64 0
-#define defaultNaNF128UI32 0
-#define defaultNaNF128UI0 0
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_beforeRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0
+#define ui32_fromNaN         0
+#define i32_fromPosOverflow  0x7FFFFFFF
+#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNaN          0
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow 0
+#define ui64_fromNaN         0
+#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN          0
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN {
+    bool sign;
+#ifdef LITTLEENDIAN
+    uint64_t v0, v64;
+#else
+    uint64_t v64, v0;
+#endif
+};
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0x7E00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0x7FC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0x7FFF
+#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80UIToCommonNaN(
+     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
+#define defaultNaNF128UI0  UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128UIToCommonNaN(
+     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_extF80MToCommonNaN(
+     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0x7FFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0  0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/RISCV/extF80M_isSignalingNaN.c b/softfloat/source/RISCV/extF80M_isSignalingNaN.c
index 85ee211..c2cca65 100644
--- a/softfloat/source/RISCV/extF80M_isSignalingNaN.c
+++ b/softfloat/source/RISCV/extF80M_isSignalingNaN.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint64_t uiA0;
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
-    uiA0 = aSPtr->signif;
-    return
-        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
-            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool extF80M_isSignalingNaN( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint64_t uiA0;
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    if ( (aSPtr->signExp & 0x7FFF) != 0x7FFF ) return false;
+    uiA0 = aSPtr->signif;
+    return
+        ! (uiA0 & UINT64_C( 0x4000000000000000 ))
+            && (uiA0 & UINT64_C( 0x3FFFFFFFFFFFFFFF));
+
+}
+
diff --git a/softfloat/source/RISCV/f128M_isSignalingNaN.c b/softfloat/source/RISCV/f128M_isSignalingNaN.c
index 79a7077..9ff83d7 100644
--- a/softfloat/source/RISCV/f128M_isSignalingNaN.c
+++ b/softfloat/source/RISCV/f128M_isSignalingNaN.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool f128M_isSignalingNaN( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
-    return
-        ((uiA96 & 0x00007FFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool f128M_isSignalingNaN( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (uiA96 & 0x7FFF8000) != 0x7FFF0000 ) return false;
+    return
+        ((uiA96 & 0x00007FFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/RISCV/s_bf16UIToCommonNaN.c b/softfloat/source/RISCV/s_bf16UIToCommonNaN.c
new file mode 100644
index 0000000..861b269
--- /dev/null
+++ b/softfloat/source/RISCV/s_bf16UIToCommonNaN.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_commonNaNToBF16UI.c b/softfloat/source/RISCV/s_commonNaNToBF16UI.c
new file mode 100644
index 0000000..861b269
--- /dev/null
+++ b/softfloat/source/RISCV/s_commonNaNToBF16UI.c
@@ -0,0 +1,5 @@
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_commonNaNToExtF80M.c b/softfloat/source/RISCV/s_commonNaNToExtF80M.c
index 3405b3b..6d1e67e 100644
--- a/softfloat/source/RISCV/s_commonNaNToExtF80M.c
+++ b/softfloat/source/RISCV/s_commonNaNToExtF80M.c
@@ -1,56 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| `zSPtr'.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
-
-    zSPtr->signExp = packToExtF80UI64( aPtr->sign, 0x7FFF );
-    zSPtr->signif = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat_types.h"
+
+#define softfloat_commonNaNToExtF80M softfloat_commonNaNToExtF80M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| `zSPtr'.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+
+}
+
diff --git a/softfloat/source/RISCV/s_commonNaNToExtF80UI.c b/softfloat/source/RISCV/s_commonNaNToExtF80UI.c
index cb7424f..953b97a 100644
--- a/softfloat/source/RISCV/s_commonNaNToExtF80UI.c
+++ b/softfloat/source/RISCV/s_commonNaNToExtF80UI.c
@@ -1,56 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ.v64 = (uint_fast16_t) aPtr->sign<<15 | 0x7FFF;
-    uiZ.v0 = UINT64_C( 0xC000000000000000 ) | aPtr->v64>>1;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToExtF80UI softfloat_commonNaNToExtF80UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/RISCV/s_commonNaNToF128M.c b/softfloat/source/RISCV/s_commonNaNToF128M.c
index e7ea802..d91b62e 100644
--- a/softfloat/source/RISCV/s_commonNaNToF128M.c
+++ b/softfloat/source/RISCV/s_commonNaNToF128M.c
@@ -1,56 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
-| `zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-
-    softfloat_shortShiftRight128M( (const uint32_t *) &aPtr->v0, 16, zWPtr );
-    zWPtr[indexWordHi( 4 )] |= (uint32_t) aPtr->sign<<31 | 0x7FFF8000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128M softfloat_commonNaNToF128M
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by `zWPtr'.  Argument
+| `zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/softfloat/source/RISCV/s_commonNaNToF128UI.c b/softfloat/source/RISCV/s_commonNaNToF128UI.c
index 7a9423b..b4c578d 100644
--- a/softfloat/source/RISCV/s_commonNaNToF128UI.c
+++ b/softfloat/source/RISCV/s_commonNaNToF128UI.c
@@ -1,55 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
-    struct uint128 uiZ;
-
-    uiZ = softfloat_shortShiftRight128( aPtr->v64, aPtr->v0, 16 );
-    uiZ.v64 |= (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FFF800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#define softfloat_commonNaNToF128UI softfloat_commonNaNToF128UI
+#include "specialize.h"
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by `aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/RISCV/s_commonNaNToF16UI.c b/softfloat/source/RISCV/s_commonNaNToF16UI.c
index d4e458a..861b269 100644
--- a/softfloat/source/RISCV/s_commonNaNToF16UI.c
+++ b/softfloat/source/RISCV/s_commonNaNToF16UI.c
@@ -1,51 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast16_t) aPtr->sign<<15 | 0x7E00 | aPtr->v64>>54;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_commonNaNToF32UI.c b/softfloat/source/RISCV/s_commonNaNToF32UI.c
index ed6c226..861b269 100644
--- a/softfloat/source/RISCV/s_commonNaNToF32UI.c
+++ b/softfloat/source/RISCV/s_commonNaNToF32UI.c
@@ -1,51 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr )
-{
-
-    return (uint_fast32_t) aPtr->sign<<31 | 0x7FC00000 | aPtr->v64>>41;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_commonNaNToF64UI.c b/softfloat/source/RISCV/s_commonNaNToF64UI.c
index 1182be3..861b269 100644
--- a/softfloat/source/RISCV/s_commonNaNToF64UI.c
+++ b/softfloat/source/RISCV/s_commonNaNToF64UI.c
@@ -1,53 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by `aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr )
-{
-
-    return
-        (uint_fast64_t) aPtr->sign<<63 | UINT64_C( 0x7FF8000000000000 )
-            | aPtr->v64>>12;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_extF80MToCommonNaN.c b/softfloat/source/RISCV/s_extF80MToCommonNaN.c
index 00baf35..861b269 100644
--- a/softfloat/source/RISCV/s_extF80MToCommonNaN.c
+++ b/softfloat/source/RISCV/s_extF80MToCommonNaN.c
@@ -1,62 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by `aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by `zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr )
-{
-
-    if ( extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = signExtF80UI64( aSPtr->signExp );
-    zPtr->v64 = aSPtr->signif<<1;
-    zPtr->v0  = 0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_extF80UIToCommonNaN.c b/softfloat/source/RISCV/s_extF80UIToCommonNaN.c
index ab6311e..861b269 100644
--- a/softfloat/source/RISCV/s_extF80UIToCommonNaN.c
+++ b/softfloat/source/RISCV/s_extF80UIToCommonNaN.c
@@ -1,62 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA64>>15;
-    zPtr->v64  = uiA0<<1;
-    zPtr->v0   = 0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_f128MToCommonNaN.c b/softfloat/source/RISCV/s_f128MToCommonNaN.c
index 55ec25b..861b269 100644
--- a/softfloat/source/RISCV/s_f128MToCommonNaN.c
+++ b/softfloat/source/RISCV/s_f128MToCommonNaN.c
@@ -1,62 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by `aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by `zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument `aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr )
-{
-
-    if ( f128M_isSignalingNaN( (const float128_t *) aWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = aWPtr[indexWordHi( 4 )]>>31;
-    softfloat_shortShiftLeft128M( aWPtr, 16, (uint32_t *) &zPtr->v0 );
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_f128UIToCommonNaN.c b/softfloat/source/RISCV/s_f128UIToCommonNaN.c
index f838f02..861b269 100644
--- a/softfloat/source/RISCV/s_f128UIToCommonNaN.c
+++ b/softfloat/source/RISCV/s_f128UIToCommonNaN.c
@@ -1,65 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating `uiA64' and `uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr )
-{
-    struct uint128 NaNSig;
-
-    if ( softfloat_isSigNaNF128UI( uiA64, uiA0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    NaNSig = softfloat_shortShiftLeft128( uiA64, uiA0, 16 );
-    zPtr->sign = uiA64>>63;
-    zPtr->v64  = NaNSig.v64;
-    zPtr->v0   = NaNSig.v0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_f16UIToCommonNaN.c b/softfloat/source/RISCV/s_f16UIToCommonNaN.c
index c1e242d..861b269 100644
--- a/softfloat/source/RISCV/s_f16UIToCommonNaN.c
+++ b/softfloat/source/RISCV/s_f16UIToCommonNaN.c
@@ -1,59 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF16UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>15;
-    zPtr->v64  = (uint_fast64_t) uiA<<54;
-    zPtr->v0   = 0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_f32UIToCommonNaN.c b/softfloat/source/RISCV/s_f32UIToCommonNaN.c
index b21ba66..861b269 100644
--- a/softfloat/source/RISCV/s_f32UIToCommonNaN.c
+++ b/softfloat/source/RISCV/s_f32UIToCommonNaN.c
@@ -1,59 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF32UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>31;
-    zPtr->v64  = (uint_fast64_t) uiA<<41;
-    zPtr->v0   = 0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_f64UIToCommonNaN.c b/softfloat/source/RISCV/s_f64UIToCommonNaN.c
index 6529d2e..861b269 100644
--- a/softfloat/source/RISCV/s_f64UIToCommonNaN.c
+++ b/softfloat/source/RISCV/s_f64UIToCommonNaN.c
@@ -1,59 +1,5 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming `uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by `zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr )
-{
-
-    if ( softfloat_isSigNaNF64UI( uiA ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    zPtr->sign = uiA>>63;
-    zPtr->v64  = uiA<<12;
-    zPtr->v0   = 0;
-
-}
-
+
+/*----------------------------------------------------------------------------
+| This file intentionally contains no code.
+*----------------------------------------------------------------------------*/
+
diff --git a/softfloat/source/RISCV/s_propagateNaNExtF80M.c b/softfloat/source/RISCV/s_propagateNaNExtF80M.c
index ea1d57a..8adc62e 100644
--- a/softfloat/source/RISCV/s_propagateNaNExtF80M.c
+++ b/softfloat/source/RISCV/s_propagateNaNExtF80M.c
@@ -1,107 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by `zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    bool isSigNaNA;
-    const struct extFloat80M *sPtr;
-    bool isSigNaNB;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiMagA64, uiMagB64;
-
-    isSigNaNA = extF80M_isSignalingNaN( (const extFloat80_t *) aSPtr );
-    sPtr = aSPtr;
-    if ( ! bSPtr ) {
-        if ( isSigNaNA ) softfloat_raiseFlags( softfloat_flag_invalid );
-        goto copy;
-    }
-    isSigNaNB = extF80M_isSignalingNaN( (const extFloat80_t *) bSPtr );
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            uiB64 = bSPtr->signExp;
-            if ( isSigNaNB ) goto returnLargerUIMag;
-            uiB0 = bSPtr->signif;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto copyB;
-            goto copy;
-        } else {
-            uiA64 = aSPtr->signExp;
-            uiA0 = aSPtr->signif;
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto copy;
-            goto copyB;
-        }
-    }
-    uiB64 = bSPtr->signExp;
- returnLargerUIMag:
-    uiA64 = aSPtr->signExp;
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto copyB;
-    if ( uiMagB64 < uiMagA64 ) goto copy;
-    uiA0 = aSPtr->signif;
-    uiB0 = bSPtr->signif;
-    if ( uiA0 < uiB0 ) goto copyB;
-    if ( uiB0 < uiA0 ) goto copy;
-    if ( uiA64 < uiB64 ) goto copy;
- copyB:
-    sPtr = bSPtr;
- copy:
-    zSPtr->signExp = sPtr->signExp;
-    zSPtr->signif = sPtr->signif | UINT64_C( 0xC000000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by `aSPtr' and `bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by `zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    uint_fast16_t ui64;
+    uint_fast64_t ui0;
+
+    ui64 = aSPtr->signExp;
+    ui0  = aSPtr->signif;
+    if (
+        softfloat_isSigNaNExtF80UI( ui64, ui0 )
+            || (bSPtr
+                    && (ui64 = bSPtr->signExp,
+                        ui0  = bSPtr->signif,
+                        softfloat_isSigNaNExtF80UI( ui64, ui0 )))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNExtF80UI.c b/softfloat/source/RISCV/s_propagateNaNExtF80UI.c
index cc3f0f4..88bfee5 100644
--- a/softfloat/source/RISCV/s_propagateNaNExtF80UI.c
+++ b/softfloat/source/RISCV/s_propagateNaNExtF80UI.c
@@ -1,106 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2018 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA, isSigNaNB;
-    uint_fast64_t uiNonsigA0, uiNonsigB0;
-    uint_fast16_t uiMagA64, uiMagB64;
-    struct uint128 uiZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    isSigNaNA = softfloat_isSigNaNExtF80UI( uiA64, uiA0 );
-    isSigNaNB = softfloat_isSigNaNExtF80UI( uiB64, uiB0 );
-    /*------------------------------------------------------------------------
-    | Make NaNs non-signaling.
-    *------------------------------------------------------------------------*/
-    uiNonsigA0 = uiA0 | UINT64_C( 0xC000000000000000 );
-    uiNonsigB0 = uiB0 | UINT64_C( 0xC000000000000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isSigNaNA | isSigNaNB ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) {
-            if ( isSigNaNB ) goto returnLargerMag;
-            if ( isNaNExtF80UI( uiB64, uiB0 ) ) goto returnB;
-            goto returnA;
-        } else {
-            if ( isNaNExtF80UI( uiA64, uiA0 ) ) goto returnA;
-            goto returnB;
-        }
-    }
- returnLargerMag:
-    uiMagA64 = uiA64 & 0x7FFF;
-    uiMagB64 = uiB64 & 0x7FFF;
-    if ( uiMagA64 < uiMagB64 ) goto returnB;
-    if ( uiMagB64 < uiMagA64 ) goto returnA;
-    if ( uiA0 < uiB0 ) goto returnB;
-    if ( uiB0 < uiA0 ) goto returnA;
-    if ( uiA64 < uiB64 ) goto returnA;
- returnB:
-    uiZ.v64 = uiB64;
-    uiZ.v0  = uiNonsigB0;
-    return uiZ;
- returnA:
-    uiZ.v64 = uiA64;
-    uiZ.v0  = uiNonsigA0;
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating `uiA64' and
+| `uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating `uiB64' and `uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    struct uint128 uiZ;
+
+    if (
+           softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+        || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNF128M.c b/softfloat/source/RISCV/s_propagateNaNF128M.c
index aa903bf..df76ab2 100644
--- a/softfloat/source/RISCV/s_propagateNaNF128M.c
+++ b/softfloat/source/RISCV/s_propagateNaNF128M.c
@@ -1,76 +1,68 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| `aWPtr' and `bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by `zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of `aWPtr', `bWPtr',
-| and `zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-    bool isSigNaNA;
-    const uint32_t *ptr;
-
-    ptr = aWPtr;
-    isSigNaNA = f128M_isSignalingNaN( (const float128_t *) aWPtr );
-    if (
-        isSigNaNA
-            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto copy;
-    }
-    if ( ! softfloat_isNaNF128M( aWPtr ) ) ptr = bWPtr;
- copy:
-    zWPtr[indexWordHi( 4 )] = ptr[indexWordHi( 4 )] | 0x00008000;
-    zWPtr[indexWord( 4, 2 )] = ptr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = ptr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = ptr[indexWord( 4, 0 )];
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2018 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+
+    if (
+        f128M_isSignalingNaN( (const float128_t *) aWPtr )
+            || (bWPtr && f128M_isSignalingNaN( (const float128_t *) bWPtr ))
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNF128UI.c b/softfloat/source/RISCV/s_propagateNaNF128UI.c
index 1c1c2f4..49e2535 100644
--- a/softfloat/source/RISCV/s_propagateNaNF128UI.c
+++ b/softfloat/source/RISCV/s_propagateNaNF128UI.c
@@ -1,81 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating `uiA64' and
-| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- )
-{
-    bool isSigNaNA;
-    struct uint128 uiZ;
-
-    isSigNaNA = softfloat_isSigNaNF128UI( uiA64, uiA0 );
-    if ( isSigNaNA || softfloat_isSigNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) goto returnNonsigA;
-    }
-    if ( isNaNF128UI( uiA64, uiA0 ) ) {
- returnNonsigA:
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-    } else {
-        uiZ.v64 = uiB64;
-        uiZ.v0  = uiB0;
-    }
-    uiZ.v64 |= UINT64_C( 0x0000800000000000 );
-    return uiZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating `uiA64' and
+| `uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating `uiB64' and `uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ )
+{
+    struct uint128 uiZ;
+
+    if (
+           softfloat_isSigNaNF128UI( uiA64, uiA0 )
+        || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNF16UI.c b/softfloat/source/RISCV/s_propagateNaNF16UI.c
index 4e87ff4..228dcd8 100644
--- a/softfloat/source/RISCV/s_propagateNaNF16UI.c
+++ b/softfloat/source/RISCV/s_propagateNaNF16UI.c
@@ -1,63 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF16UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | 0x0200;
-    }
-    return (isNaNF16UI( uiA ) ? uiA : uiB) | 0x0200;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+
+    if ( softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF16UI;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNF32UI.c b/softfloat/source/RISCV/s_propagateNaNF32UI.c
index e1a8755..c6308cc 100644
--- a/softfloat/source/RISCV/s_propagateNaNF32UI.c
+++ b/softfloat/source/RISCV/s_propagateNaNF32UI.c
@@ -1,63 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF32UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | 0x00400000;
-    }
-    return (isNaNF32UI( uiA ) ? uiA : uiB) | 0x00400000;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+
+    if ( softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF32UI;
+
+}
+
diff --git a/softfloat/source/RISCV/s_propagateNaNF64UI.c b/softfloat/source/RISCV/s_propagateNaNF64UI.c
index 1af349f..2203665 100644
--- a/softfloat/source/RISCV/s_propagateNaNF64UI.c
+++ b/softfloat/source/RISCV/s_propagateNaNF64UI.c
@@ -1,63 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
-{
-    bool isSigNaNA;
-
-    isSigNaNA = softfloat_isSigNaNF64UI( uiA );
-    if ( isSigNaNA || softfloat_isSigNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        if ( isSigNaNA ) return uiA | UINT64_C( 0x0008000000000000 );
-    }
-    return (isNaNF64UI( uiA ) ? uiA : uiB) | UINT64_C( 0x0008000000000000 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Interpreting `uiA' and `uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either `uiA' or `uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB )
+{
+
+    if ( softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return defaultNaNF64UI;
+
+}
+
diff --git a/softfloat/source/RISCV/softfloat_raiseFlags.c b/softfloat/source/RISCV/softfloat_raiseFlags.c
index 3115306..7a1aee9 100644
--- a/softfloat/source/RISCV/softfloat_raiseFlags.c
+++ b/softfloat/source/RISCV/softfloat_raiseFlags.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "softfloat.h"
-
-/*----------------------------------------------------------------------------
-| Raises the exceptions specified by `flags'.  Floating-point traps can be
-| defined here if desired.  It is currently not possible for such a trap
-| to substitute a result value.  If traps are not implemented, this routine
-| should be simply `softfloat_exceptionFlags |= flags;'.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t flags )
-{
-
-    softfloat_exceptionFlags |= flags;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Raises the exceptions specified by `flags'.  Floating-point traps can be
+| defined here if desired.  It is currently not possible for such a trap
+| to substitute a result value.  If traps are not implemented, this routine
+| should be simply `softfloat_exceptionFlags |= flags;'.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t flags )
+{
+
+    softfloat_exceptionFlags |= flags;
+
+}
+
diff --git a/softfloat/source/RISCV/specialize.h b/softfloat/source/RISCV/specialize.h
index f0cb14c..cb95900 100644
--- a/softfloat/source/RISCV/specialize.h
+++ b/softfloat/source/RISCV/specialize.h
@@ -1,346 +1,433 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef specialize_h
-#define specialize_h 1
-
-#include "primitiveTypes.h"
-#include "softfloat.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Default value for 'softfloat_detectTininess'.
-*----------------------------------------------------------------------------*/
-#define init_detectTininess softfloat_tininess_afterRounding
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 32-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui32_fromPosOverflow UINT32_C(0xFFFFFFFF)
-#define ui32_fromNegOverflow UINT32_C(0x0)
-#define ui32_fromNaN UINT32_C(0xFFFFFFFF)
-#define i32_fromPosOverflow INT64_C(0x7FFFFFFF)
-#define i32_fromNegOverflow (-INT64_C(0x7FFFFFFF) - 1)
-#define i32_fromNaN INT64_C(0x7FFFFFFF)
-
-/*----------------------------------------------------------------------------
-| The values to return on conversions to 64-bit integer formats that raise an
-| invalid exception.
-*----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define ui64_fromNegOverflow UINT64_C(0x0)
-#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
-#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
-#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
-#define i64_fromNaN INT64_C(0x7FFFFFFFFFFFFFFF)
-
-/*----------------------------------------------------------------------------
-| "Common NaN" structure, used to transfer NaN representations from one format
-| to another.
-*----------------------------------------------------------------------------*/
-struct commonNaN {
-    bool sign;
-#ifdef LITTLEENDIAN
-    uint64_t v0, v64;
-#else
-    uint64_t v64, v0;
-#endif
-};
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 16-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF16UI 0xFE00
-
-/*----------------------------------------------------------------------------
-| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
-| 16-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 32-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF32UI 0x7FC00000
-
-/*----------------------------------------------------------------------------
-| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
-| 32-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 64-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
-| 64-bit floating-point signaling NaN.
-| Note:  This macro evaluates its argument more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
-    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
-
-/*----------------------------------------------------------------------------
-| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
-| point values, at least one of which is a NaN, returns the bit pattern of
-| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
-| signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 80-bit extended floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNExtF80UI64 0xFFFF
-#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 80-bit unsigned integer formed from concatenating
-| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
-| floating-point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
-    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of an 80-bit extended floating-point NaN, converts
-| this NaN to the common NaN form, and stores the resulting common NaN at the
-| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and returns the bit pattern of this value as an unsigned
-| integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
-| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 80-bit extended floating-point value, and assuming at least on of these
-| floating-point values is a NaN, returns the bit pattern of the combined NaN
-| result.  If either original floating-point value is a signaling NaN, the
-| invalid exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
-#define defaultNaNF128UI0 UINT64_C(0)
-
-/*----------------------------------------------------------------------------
-| Returns true when the 128-bit unsigned integer formed from concatenating
-| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
-| point signaling NaN.
-| Note:  This macro evaluates its arguments more than once.
-*----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
-    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
-
-/*----------------------------------------------------------------------------
-| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
-| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
-| the common NaN form, and stores the resulting common NaN at the location
-| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
-| is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and returns the bit pattern of this value as an unsigned integer.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
-
-/*----------------------------------------------------------------------------
-| Interpreting the unsigned integer formed from concatenating 'uiA64' and
-| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
-| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
-| 128-bit floating-point value, and assuming at least on of these floating-
-| point values is a NaN, returns the bit pattern of the combined NaN result.
-| If either original floating-point value is a signaling NaN, the invalid
-| exception is raised.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-/*----------------------------------------------------------------------------
-| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
-| a NaN, converts this NaN to the common NaN form, and stores the resulting
-| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
-| NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
-| floating-point NaN, and stores this NaN at the location pointed to by
-| 'zSPtr'.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 80-bit extended floating-point values
-| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
-| at the location pointed to by 'zSPtr'.  If either original floating-point
-| value is a signaling NaN, the invalid exception is raised.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
-
-/*----------------------------------------------------------------------------
-| The bit pattern for a default generated 128-bit floating-point NaN.
-*----------------------------------------------------------------------------*/
-#define defaultNaNF128UI96 0xFFFF8000
-#define defaultNaNF128UI64 0
-#define defaultNaNF128UI32 0
-#define defaultNaNF128UI0 0
-
-/*----------------------------------------------------------------------------
-| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
-| converts this NaN to the common NaN form, and stores the resulting common
-| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
-| the invalid exception is raised.  Argument 'aWPtr' points to an array of
-| four 32-bit elements that concatenate in the platform's normal endian order
-| to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
-
-/*----------------------------------------------------------------------------
-| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
-| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
-| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
-| platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
-
-/*----------------------------------------------------------------------------
-| Assuming at least one of the two 128-bit floating-point values pointed to by
-| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
-| pointed to by 'zWPtr'.  If either original floating-point value is a
-| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
-| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
-| the platform's normal endian order to form a 128-bit floating-point value.
-*----------------------------------------------------------------------------*/
-void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef specialize_h
+#define specialize_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+#include "softfloat.h"
+
+/*----------------------------------------------------------------------------
+| Default value for 'softfloat_detectTininess'.
+*----------------------------------------------------------------------------*/
+#define init_detectTininess softfloat_tininess_afterRounding
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 32-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui32_fromPosOverflow 0xFFFFFFFF
+#define ui32_fromNegOverflow 0
+#define ui32_fromNaN         0xFFFFFFFF
+#define i32_fromPosOverflow  0x7FFFFFFF
+#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
+#define i32_fromNaN          0x7FFFFFFF
+
+/*----------------------------------------------------------------------------
+| The values to return on conversions to 64-bit integer formats that raise an
+| invalid exception.
+*----------------------------------------------------------------------------*/
+#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromNegOverflow 0
+#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define i64_fromNaN          INT64_C( 0x7FFFFFFFFFFFFFFF )
+
+/*----------------------------------------------------------------------------
+| "Common NaN" structure, used to transfer NaN representations from one format
+| to another.
+*----------------------------------------------------------------------------*/
+struct commonNaN { char _unused; };
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF16UI 0x7E00
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+
+/*----------------------------------------------------------------------------
+| Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
+| 16-bit brain floating-point (BF16) signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_bf16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0040) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast16_t
+ softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 16-bit BF16 floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNBF16UI 0x7FC0
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToBF16UI( aPtr ) ((uint_fast16_t) defaultNaNBF16UI)
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 32-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF32UI 0x7FC00000
+
+/*----------------------------------------------------------------------------
+| Returns true when 32-bit unsigned integer 'uiA' has the bit pattern of a
+| 32-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast32_t
+ softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 64-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
+| 64-bit floating-point signaling NaN.
+| Note:  This macro evaluates its argument more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+
+/*----------------------------------------------------------------------------
+| Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
+
+/*----------------------------------------------------------------------------
+| Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
+| point values, at least one of which is a NaN, returns the bit pattern of
+| the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
+| signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+uint_fast64_t
+ softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 80-bit extended floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNExtF80UI64 0x7FFF
+#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 80-bit unsigned integer formed from concatenating
+| 16-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of an 80-bit extended
+| floating-point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of an 80-bit extended floating-point NaN, converts
+| this NaN to the common NaN form, and stores the resulting common NaN at the
+| location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and returns the bit pattern of this value as an unsigned
+| integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
+INLINE
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+    uiZ.v64 = defaultNaNExtF80UI64;
+    uiZ.v0  = defaultNaNExtF80UI0;
+    return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as an 80-bit extended floating-point value, and likewise interpreting
+| the unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 80-bit extended floating-point value, and assuming at least on of these
+| floating-point values is a NaN, returns the bit pattern of the combined NaN
+| result.  If either original floating-point value is a signaling NaN, the
+| invalid exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNExtF80UI(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
+#define defaultNaNF128UI0  UINT64_C( 0 )
+
+/*----------------------------------------------------------------------------
+| Returns true when the 128-bit unsigned integer formed from concatenating
+| 64-bit 'uiA64' and 64-bit 'uiA0' has the bit pattern of a 128-bit floating-
+| point signaling NaN.
+| Note:  This macro evaluates its arguments more than once.
+*----------------------------------------------------------------------------*/
+#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+
+/*----------------------------------------------------------------------------
+| Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
+| has the bit pattern of a 128-bit floating-point NaN, converts this NaN to
+| the common NaN form, and stores the resulting common NaN at the location
+| pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
+| is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and returns the bit pattern of this value as an unsigned integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128UI
+INLINE
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
+{
+    struct uint128 uiZ;
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    return uiZ;
+}
+#else
+struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+#endif
+
+/*----------------------------------------------------------------------------
+| Interpreting the unsigned integer formed from concatenating 'uiA64' and
+| 'uiA0' as a 128-bit floating-point value, and likewise interpreting the
+| unsigned integer formed from concatenating 'uiB64' and 'uiB0' as another
+| 128-bit floating-point value, and assuming at least on of these floating-
+| point values is a NaN, returns the bit pattern of the combined NaN result.
+| If either original floating-point value is a signaling NaN, the invalid
+| exception is raised.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_propagateNaNF128UI(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+/*----------------------------------------------------------------------------
+| Assuming the 80-bit extended floating-point value pointed to by 'aSPtr' is
+| a NaN, converts this NaN to the common NaN form, and stores the resulting
+| common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
+| NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
+| floating-point NaN, and stores this NaN at the location pointed to by
+| 'zSPtr'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
+INLINE
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
+{
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+}
+#else
+void
+ softfloat_commonNaNToExtF80M(
+     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 80-bit extended floating-point values
+| pointed to by 'aSPtr' and 'bSPtr' is a NaN, stores the combined NaN result
+| at the location pointed to by 'zSPtr'.  If either original floating-point
+| value is a signaling NaN, the invalid exception is raised.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ );
+
+/*----------------------------------------------------------------------------
+| The bit pattern for a default generated 128-bit floating-point NaN.
+*----------------------------------------------------------------------------*/
+#define defaultNaNF128UI96 0x7FFF8000
+#define defaultNaNF128UI64 0
+#define defaultNaNF128UI32 0
+#define defaultNaNF128UI0  0
+
+/*----------------------------------------------------------------------------
+| Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
+| converts this NaN to the common NaN form, and stores the resulting common
+| NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling NaN,
+| the invalid exception is raised.  Argument 'aWPtr' points to an array of
+| four 32-bit elements that concatenate in the platform's normal endian order
+| to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+
+/*----------------------------------------------------------------------------
+| Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
+| NaN, and stores this NaN at the location pointed to by 'zWPtr'.  Argument
+| 'zWPtr' points to an array of four 32-bit elements that concatenate in the
+| platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+#if defined INLINE && ! defined softfloat_commonNaNToF128M
+INLINE
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
+{
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+}
+#else
+void
+ softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+#endif
+
+/*----------------------------------------------------------------------------
+| Assuming at least one of the two 128-bit floating-point values pointed to by
+| 'aWPtr' and 'bWPtr' is a NaN, stores the combined NaN result at the location
+| pointed to by 'zWPtr'.  If either original floating-point value is a
+| signaling NaN, the invalid exception is raised.  Each of 'aWPtr', 'bWPtr',
+| and 'zWPtr' points to an array of four 32-bit elements that concatenate in
+| the platform's normal endian order to form a 128-bit floating-point value.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_propagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/bf16_isSignalingNaN.c b/softfloat/source/bf16_isSignalingNaN.c
new file mode 100644
index 0000000..79ca87f
--- /dev/null
+++ b/softfloat/source/bf16_isSignalingNaN.c
@@ -0,0 +1,51 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool bf16_isSignalingNaN( bfloat16_t a )
+{
+    union ui16_bf16 uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNBF16UI( uA.ui );
+
+}
+
diff --git a/softfloat/source/bf16_to_f32.c b/softfloat/source/bf16_to_f32.c
new file mode 100644
index 0000000..b86482c
--- /dev/null
+++ b/softfloat/source/bf16_to_f32.c
@@ -0,0 +1,90 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t bf16_to_f32( bfloat16_t a )
+{
+    union ui16_bf16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast16_t frac;
+    struct commonNaN commonNaN;
+    uint_fast32_t uiZ;
+    struct exp8_sig16 normExpSig;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signBF16UI( uiA );
+    exp  = expBF16UI( uiA );
+    frac = fracBF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // NaN or Inf
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_bf16UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // packToF32UI simply packs bitfields without any numerical change
+    // which means it can be used directly for any BF16 to f32 conversions which
+    // does not require bits manipulation
+    // (that is everything where the 16-bit are just padded right with 16 zeros, including
+    //  subnormal numbers)
+    uiZ = packToF32UI( sign, exp, ((uint_fast32_t) frac) <<16 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+
+
diff --git a/softfloat/source/extF80M_add.c b/softfloat/source/extF80M_add.c
index 02e415f..4ba6a31 100644
--- a/softfloat/source/extF80M_add.c
+++ b/softfloat/source/extF80M_add.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    extFloat80_t
-        (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
-#endif
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    signA = signExtF80UI64( uiA64 );
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    signB = signExtF80UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
-#else
-
-void
- extF80M_add(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-
-    softfloat_addExtF80M(
-        (const struct extFloat80M *) aPtr,
-        (const struct extFloat80M *) bPtr,
-        (struct extFloat80M *) zPtr,
-        false
-    );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_add(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    extFloat80_t
+        (*magsFuncPtr)(
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    signA = signExtF80UI64( uiA64 );
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ extF80M_add(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+    softfloat_addExtF80M(
+        (const struct extFloat80M *) aPtr,
+        (const struct extFloat80M *) bPtr,
+        (struct extFloat80M *) zPtr,
+        false
+    );
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_div.c b/softfloat/source/extF80M_div.c
index 4d543ce..24c069a 100644
--- a/softfloat/source/extF80M_div.c
+++ b/softfloat/source/extF80M_div.c
@@ -1,194 +1,194 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-
-    *zPtr = extF80_div( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- extF80M_div(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiA64;
-    int32_t expA;
-    uint_fast16_t uiB64;
-    int32_t expB;
-    bool signZ;
-    uint64_t sigA, x64;
-    int32_t expZ;
-    int shiftDist;
-    uint32_t y[3], recip32, sigB[3];
-    int ix;
-    uint32_t q, qs[2];
-    uint_fast16_t uiZ64;
-    uint64_t uiZ0;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    expA = expExtF80UI64( uiA64 );
-    uiB64 = bSPtr->signExp;
-    expB = expExtF80UI64( uiB64 );
-    signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
-        if ( expA == 0x7FFF ) {
-            if ( expB == 0x7FFF ) goto invalid;
-            goto infinity;
-        }
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigA = aSPtr->signif;
-    x64 = bSPtr->signif;
-    if ( ! expB ) expB = 1;
-    if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! x64 ) {
-            if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        expB += softfloat_normExtF80SigM( &x64 );
-    }
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) goto zero;
-        expA += softfloat_normExtF80SigM( &sigA );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x3FFF;
-    shiftDist = 29;
-    if ( sigA < x64 ) {
-        --expZ;
-        shiftDist = 30;
-    }
-    softfloat_shortShiftLeft64To96M( sigA, shiftDist, y );
-    recip32 = softfloat_approxRecip32_1( x64>>32 );
-    sigB[indexWord( 3, 0 )] = (uint32_t) x64<<30;
-    x64 >>= 2;
-    sigB[indexWord( 3, 2 )] = x64>>32;
-    sigB[indexWord( 3, 1 )] = x64;
-    ix = 2;
-    for (;;) {
-        x64 = (uint64_t) y[indexWordHi( 3 )] * recip32;
-        q = (x64 + 0x80000000)>>32;
-        --ix;
-        if ( ix < 0 ) break;
-        softfloat_remStep96MBy32( y, 29, sigB, q, y );
-        if ( y[indexWordHi( 3 )] & 0x80000000 ) {
-            --q;
-            softfloat_add96M( y, sigB, y );
-        }
-        qs[ix] = q;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ((q + 1) & 0x3FFFFF) < 2 ) {
-        softfloat_remStep96MBy32( y, 29, sigB, q, y );
-        if ( y[indexWordHi( 3 )] & 0x80000000 ) {
-            --q;
-            softfloat_add96M( y, sigB, y );
-        } else if ( softfloat_compare96M( sigB, y ) <= 0 ) {
-            ++q;
-            softfloat_sub96M( y, sigB, y );
-        }
-        if (
-            y[indexWordLo( 3 )] || y[indexWord( 3, 1 )] || y[indexWord( 3, 2 )]
-        ) {
-            q |= 1;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    x64 = (uint64_t) q<<9;
-    y[indexWord( 3, 0 )] = x64;
-    x64 = ((uint64_t) qs[0]<<6) + (x64>>32);
-    y[indexWord( 3, 1 )] = x64;
-    y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
-    softfloat_roundPackMToExtF80M(
-        signZ, expZ, y, extF80_roundingPrecision, zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidExtF80M( zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
-    uiZ0  = UINT64_C( 0x8000000000000000 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ64 = packToExtF80UI64( signZ, 0 );
-    uiZ0  = 0;
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif  = uiZ0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_div(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+    *zPtr = extF80_div( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_div(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiA64;
+    int32_t expA;
+    uint_fast16_t uiB64;
+    int32_t expB;
+    bool signZ;
+    uint64_t sigA, x64;
+    int32_t expZ;
+    int shiftDist;
+    uint32_t y[3], recip32, sigB[3];
+    int ix;
+    uint32_t q, qs[2];
+    uint_fast16_t uiZ64;
+    uint64_t uiZ0;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    expA = expExtF80UI64( uiA64 );
+    uiB64 = bSPtr->signExp;
+    expB = expExtF80UI64( uiB64 );
+    signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( expA == 0x7FFF ) {
+            if ( expB == 0x7FFF ) goto invalid;
+            goto infinity;
+        }
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigA = aSPtr->signif;
+    x64 = bSPtr->signif;
+    if ( ! expB ) expB = 1;
+    if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! x64 ) {
+            if ( ! sigA ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        expB += softfloat_normExtF80SigM( &x64 );
+    }
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) goto zero;
+        expA += softfloat_normExtF80SigM( &sigA );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x3FFF;
+    shiftDist = 29;
+    if ( sigA < x64 ) {
+        --expZ;
+        shiftDist = 30;
+    }
+    softfloat_shortShiftLeft64To96M( sigA, shiftDist, y );
+    recip32 = softfloat_approxRecip32_1( x64>>32 );
+    sigB[indexWord( 3, 0 )] = (uint32_t) x64<<30;
+    x64 >>= 2;
+    sigB[indexWord( 3, 2 )] = x64>>32;
+    sigB[indexWord( 3, 1 )] = x64;
+    ix = 2;
+    for (;;) {
+        x64 = (uint64_t) y[indexWordHi( 3 )] * recip32;
+        q = (x64 + 0x80000000)>>32;
+        --ix;
+        if ( ix < 0 ) break;
+        softfloat_remStep96MBy32( y, 29, sigB, q, y );
+        if ( y[indexWordHi( 3 )] & 0x80000000 ) {
+            --q;
+            softfloat_add96M( y, sigB, y );
+        }
+        qs[ix] = q;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ((q + 1) & 0x3FFFFF) < 2 ) {
+        softfloat_remStep96MBy32( y, 29, sigB, q, y );
+        if ( y[indexWordHi( 3 )] & 0x80000000 ) {
+            --q;
+            softfloat_add96M( y, sigB, y );
+        } else if ( softfloat_compare96M( sigB, y ) <= 0 ) {
+            ++q;
+            softfloat_sub96M( y, sigB, y );
+        }
+        if (
+            y[indexWordLo( 3 )] || y[indexWord( 3, 1 )] || y[indexWord( 3, 2 )]
+        ) {
+            q |= 1;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    x64 = (uint64_t) q<<9;
+    y[indexWord( 3, 0 )] = x64;
+    x64 = ((uint64_t) qs[0]<<6) + (x64>>32);
+    y[indexWord( 3, 1 )] = x64;
+    y[indexWord( 3, 2 )] = (qs[1]<<3) + (x64>>32);
+    softfloat_roundPackMToExtF80M(
+        signZ, expZ, y, extF80_roundingPrecision, zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidExtF80M( zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+    uiZ0  = UINT64_C( 0x8000000000000000 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ64 = packToExtF80UI64( signZ, 0 );
+    uiZ0  = 0;
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif  = uiZ0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_eq.c b/softfloat/source/extF80M_eq.c
index e17aa24..2480037 100644
--- a/softfloat/source/extF80M_eq.c
+++ b/softfloat/source/extF80M_eq.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_eq( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( uiA0 == uiB0 ) {
-        return (uiA64 == uiB64) || ! uiA0;
-    } else {
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
-        }
-        return false;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_eq( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_eq( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( uiA0 == uiB0 ) {
+        return (uiA64 == uiB64) || ! uiA0;
+    } else {
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
+        }
+        return false;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_eq_signaling.c b/softfloat/source/extF80M_eq_signaling.c
index c4a7322..785eba1 100644
--- a/softfloat/source/extF80M_eq_signaling.c
+++ b/softfloat/source/extF80M_eq_signaling.c
@@ -1,92 +1,92 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_eq_signaling( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( uiA0 == uiB0 ) {
-        return (uiA64 == uiB64) || ! uiA0;
-    } else {
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
-        }
-        return false;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_eq_signaling( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_eq_signaling( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( uiA0 == uiB0 ) {
+        return (uiA64 == uiB64) || ! uiA0;
+    } else {
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return ! softfloat_compareNonnormExtF80M( aSPtr, bSPtr );
+        }
+        return false;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_le.c b/softfloat/source/extF80M_le.c
index e54eb9e..24edae8 100644
--- a/softfloat/source/extF80M_le.c
+++ b/softfloat/source/extF80M_le.c
@@ -1,106 +1,106 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_le( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    bool signA, ltMags;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signExtF80UI64( uiA64 );
-    if ( (uiA64 ^ uiB64) & 0x8000 ) {
-        /*--------------------------------------------------------------------
-        | Signs are different.
-        *--------------------------------------------------------------------*/
-        return signA || ! (uiA0 | uiB0);
-    } else {
-        /*--------------------------------------------------------------------
-        | Signs are the same.
-        *--------------------------------------------------------------------*/
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
-        }
-        if ( uiA64 == uiB64 ) {
-            if ( uiA0 == uiB0 ) return true;
-            ltMags = (uiA0 < uiB0);
-        } else {
-            ltMags = (uiA64 < uiB64);
-        }
-        return signA ^ ltMags;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_le( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_le( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    bool signA, ltMags;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signExtF80UI64( uiA64 );
+    if ( (uiA64 ^ uiB64) & 0x8000 ) {
+        /*--------------------------------------------------------------------
+        | Signs are different.
+        *--------------------------------------------------------------------*/
+        return signA || ! (uiA0 | uiB0);
+    } else {
+        /*--------------------------------------------------------------------
+        | Signs are the same.
+        *--------------------------------------------------------------------*/
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
+        }
+        if ( uiA64 == uiB64 ) {
+            if ( uiA0 == uiB0 ) return true;
+            ltMags = (uiA0 < uiB0);
+        } else {
+            ltMags = (uiA64 < uiB64);
+        }
+        return signA ^ ltMags;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_le_quiet.c b/softfloat/source/extF80M_le_quiet.c
index 943f262..3880e36 100644
--- a/softfloat/source/extF80M_le_quiet.c
+++ b/softfloat/source/extF80M_le_quiet.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_le_quiet( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    bool signA, ltMags;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signExtF80UI64( uiA64 );
-    if ( (uiA64 ^ uiB64) & 0x8000 ) {
-        /*--------------------------------------------------------------------
-        | Signs are different.
-        *--------------------------------------------------------------------*/
-        return signA || ! (uiA0 | uiB0);
-    } else {
-        /*--------------------------------------------------------------------
-        | Signs are the same.
-        *--------------------------------------------------------------------*/
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
-        }
-        if ( uiA64 == uiB64 ) {
-            if ( uiA0 == uiB0 ) return true;
-            ltMags = (uiA0 < uiB0);
-        } else {
-            ltMags = (uiA64 < uiB64);
-        }
-        return signA ^ ltMags;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_le_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_le_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    bool signA, ltMags;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signExtF80UI64( uiA64 );
+    if ( (uiA64 ^ uiB64) & 0x8000 ) {
+        /*--------------------------------------------------------------------
+        | Signs are different.
+        *--------------------------------------------------------------------*/
+        return signA || ! (uiA0 | uiB0);
+    } else {
+        /*--------------------------------------------------------------------
+        | Signs are the same.
+        *--------------------------------------------------------------------*/
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) <= 0);
+        }
+        if ( uiA64 == uiB64 ) {
+            if ( uiA0 == uiB0 ) return true;
+            ltMags = (uiA0 < uiB0);
+        } else {
+            ltMags = (uiA64 < uiB64);
+        }
+        return signA ^ ltMags;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_lt.c b/softfloat/source/extF80M_lt.c
index cbc562f..70fa8f0 100644
--- a/softfloat/source/extF80M_lt.c
+++ b/softfloat/source/extF80M_lt.c
@@ -1,106 +1,106 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_lt( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    bool signA, ltMags;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signExtF80UI64( uiA64 );
-    if ( (uiA64 ^ uiB64) & 0x8000 ) {
-        /*--------------------------------------------------------------------
-        | Signs are different.
-        *--------------------------------------------------------------------*/
-        return signA && ((uiA0 | uiB0) != 0);
-    } else {
-        /*--------------------------------------------------------------------
-        | Signs are the same.
-        *--------------------------------------------------------------------*/
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
-        }
-        if ( uiA64 == uiB64 ) {
-            if ( uiA0 == uiB0 ) return false;
-            ltMags = (uiA0 < uiB0);
-        } else {
-            ltMags = (uiA64 < uiB64);
-        }
-        return signA ^ ltMags;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_lt( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_lt( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    bool signA, ltMags;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signExtF80UI64( uiA64 );
+    if ( (uiA64 ^ uiB64) & 0x8000 ) {
+        /*--------------------------------------------------------------------
+        | Signs are different.
+        *--------------------------------------------------------------------*/
+        return signA && ((uiA0 | uiB0) != 0);
+    } else {
+        /*--------------------------------------------------------------------
+        | Signs are the same.
+        *--------------------------------------------------------------------*/
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
+        }
+        if ( uiA64 == uiB64 ) {
+            if ( uiA0 == uiB0 ) return false;
+            ltMags = (uiA0 < uiB0);
+        } else {
+            ltMags = (uiA64 < uiB64);
+        }
+        return signA ^ ltMags;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_lt_quiet.c b/softfloat/source/extF80M_lt_quiet.c
index 650586d..b119af3 100644
--- a/softfloat/source/extF80M_lt_quiet.c
+++ b/softfloat/source/extF80M_lt_quiet.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-
-    return extF80_lt_quiet( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint64_t uiA0;
-    uint_fast16_t uiB64;
-    uint64_t uiB0;
-    bool signA, ltMags;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signExtF80UI64( uiA64 );
-    if ( (uiA64 ^ uiB64) & 0x8000 ) {
-        /*--------------------------------------------------------------------
-        | Signs are different.
-        *--------------------------------------------------------------------*/
-        return signA && ((uiA0 | uiB0) != 0);
-    } else {
-        /*--------------------------------------------------------------------
-        | Signs are the same.
-        *--------------------------------------------------------------------*/
-        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
-            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
-        }
-        if ( uiA64 == uiB64 ) {
-            if ( uiA0 == uiB0 ) return false;
-            ltMags = (uiA0 < uiB0);
-        } else {
-            ltMags = (uiA64 < uiB64);
-        }
-        return signA ^ ltMags;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+
+    return extF80_lt_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool extF80M_lt_quiet( const extFloat80_t *aPtr, const extFloat80_t *bPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint64_t uiA0;
+    uint_fast16_t uiB64;
+    uint64_t uiB0;
+    bool signA, ltMags;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signExtF80UI64( uiA64 );
+    if ( (uiA64 ^ uiB64) & 0x8000 ) {
+        /*--------------------------------------------------------------------
+        | Signs are different.
+        *--------------------------------------------------------------------*/
+        return signA && ((uiA0 | uiB0) != 0);
+    } else {
+        /*--------------------------------------------------------------------
+        | Signs are the same.
+        *--------------------------------------------------------------------*/
+        if ( ! ((uiA0 & uiB0) & UINT64_C( 0x8000000000000000 )) ) {
+            return (softfloat_compareNonnormExtF80M( aSPtr, bSPtr ) < 0);
+        }
+        if ( uiA64 == uiB64 ) {
+            if ( uiA0 == uiB0 ) return false;
+            ltMags = (uiA0 < uiB0);
+        } else {
+            ltMags = (uiA64 < uiB64);
+        }
+        return signA ^ ltMags;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_mul.c b/softfloat/source/extF80M_mul.c
index 281394f..2734449 100644
--- a/softfloat/source/extF80M_mul.c
+++ b/softfloat/source/extF80M_mul.c
@@ -1,139 +1,139 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-
-    *zPtr = extF80_mul( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- extF80M_mul(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiA64;
-    int32_t expA;
-    uint_fast16_t uiB64;
-    int32_t expB;
-    bool signZ;
-    uint_fast16_t exp, uiZ64;
-    uint64_t uiZ0, sigA, sigB;
-    int32_t expZ;
-    uint32_t sigProd[4], *extSigZPtr;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    expA = expExtF80UI64( uiA64 );
-    uiB64 = bSPtr->signExp;
-    expB = expExtF80UI64( uiB64 );
-    signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
-        if (
-               (! aSPtr->signif && (expA != 0x7FFF))
-            || (! bSPtr->signif && (expB != 0x7FFF))
-        ) {
-            softfloat_invalidExtF80M( zSPtr );
-            return;
-        }
-        uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
-        uiZ0  = UINT64_C( 0x8000000000000000 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) expA = 1;
-    sigA = aSPtr->signif;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) goto zero;
-        expA += softfloat_normExtF80SigM( &sigA );
-    }
-    if ( ! expB ) expB = 1;
-    sigB = bSPtr->signif;
-    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigB ) goto zero;
-        expB += softfloat_normExtF80SigM( &sigB );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FFE;
-    softfloat_mul64To128M( sigA, sigB, sigProd );
-    if ( sigProd[indexWordLo( 4 )] ) sigProd[indexWord( 4, 1 )] |= 1;
-    extSigZPtr = &sigProd[indexMultiwordHi( 4, 3 )];
-    if ( sigProd[indexWordHi( 4 )] < 0x80000000 ) {
-        --expZ;
-        softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr );
-    }
-    softfloat_roundPackMToExtF80M(
-        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ64 = packToExtF80UI64( signZ, 0 );
-    uiZ0  = 0;
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif  = uiZ0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_mul(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+    *zPtr = extF80_mul( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_mul(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiA64;
+    int32_t expA;
+    uint_fast16_t uiB64;
+    int32_t expB;
+    bool signZ;
+    uint_fast16_t exp, uiZ64;
+    uint64_t uiZ0, sigA, sigB;
+    int32_t expZ;
+    uint32_t sigProd[4], *extSigZPtr;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    expA = expExtF80UI64( uiA64 );
+    uiB64 = bSPtr->signExp;
+    expB = expExtF80UI64( uiB64 );
+    signZ = signExtF80UI64( uiA64 ) ^ signExtF80UI64( uiB64 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if (
+               (! aSPtr->signif && (expA != 0x7FFF))
+            || (! bSPtr->signif && (expB != 0x7FFF))
+        ) {
+            softfloat_invalidExtF80M( zSPtr );
+            return;
+        }
+        uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+        uiZ0  = UINT64_C( 0x8000000000000000 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) expA = 1;
+    sigA = aSPtr->signif;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) goto zero;
+        expA += softfloat_normExtF80SigM( &sigA );
+    }
+    if ( ! expB ) expB = 1;
+    sigB = bSPtr->signif;
+    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigB ) goto zero;
+        expB += softfloat_normExtF80SigM( &sigB );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FFE;
+    softfloat_mul64To128M( sigA, sigB, sigProd );
+    if ( sigProd[indexWordLo( 4 )] ) sigProd[indexWord( 4, 1 )] |= 1;
+    extSigZPtr = &sigProd[indexMultiwordHi( 4, 3 )];
+    if ( sigProd[indexWordHi( 4 )] < 0x80000000 ) {
+        --expZ;
+        softfloat_add96M( extSigZPtr, extSigZPtr, extSigZPtr );
+    }
+    softfloat_roundPackMToExtF80M(
+        signZ, expZ, extSigZPtr, extF80_roundingPrecision, zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ64 = packToExtF80UI64( signZ, 0 );
+    uiZ0  = 0;
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif  = uiZ0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_rem.c b/softfloat/source/extF80M_rem.c
index 4aff18a..065e271 100644
--- a/softfloat/source/extF80M_rem.c
+++ b/softfloat/source/extF80M_rem.c
@@ -1,204 +1,204 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-
-    *zPtr = extF80_rem( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- extF80M_rem(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiA64;
-    int32_t expA, expB;
-    uint64_t x64;
-    bool signRem;
-    uint64_t sigA;
-    int32_t expDiff;
-    uint32_t rem[3], x[3], sig32B, q, recip32, rem2[3], *remPtr, *altRemPtr;
-    uint32_t *newRemPtr, wordMeanRem;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    expA = expExtF80UI64( uiA64 );
-    expB = expExtF80UI64( bSPtr->signExp );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
-        if ( expA == 0x7FFF ) goto invalid;
-        /*--------------------------------------------------------------------
-        | If we get here, then argument b is an infinity and `expB' is 0x7FFF;
-        | Doubling `expB' is an easy way to ensure that `expDiff' later is
-        | less than -1, which will result in returning a canonicalized version
-        | of argument a.
-        *--------------------------------------------------------------------*/
-        expB += expB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) expB = 1;
-    x64 = bSPtr->signif;
-    if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! x64 ) goto invalid;
-        expB += softfloat_normExtF80SigM( &x64 );
-    }
-    signRem = signExtF80UI64( uiA64 );
-    if ( ! expA ) expA = 1;
-    sigA = aSPtr->signif;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) {
-            expA = 0;
-            goto copyA;
-        }
-        expA += softfloat_normExtF80SigM( &sigA );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( expDiff < -1 ) goto copyA;
-    rem[indexWord( 3, 2 )] = sigA>>34;
-    rem[indexWord( 3, 1 )] = sigA>>2;
-    rem[indexWord( 3, 0 )] = (uint32_t) sigA<<30;
-    x[indexWord( 3, 0 )] = (uint32_t) x64<<30;
-    sig32B = x64>>32;
-    x64 >>= 2;
-    x[indexWord( 3, 2 )] = x64>>32;
-    x[indexWord( 3, 1 )] = x64;
-    if ( expDiff < 1 ) {
-        if ( expDiff ) {
-            --expB;
-            softfloat_add96M( x, x, x );
-            q = 0;
-        } else {
-            q = (softfloat_compare96M( x, rem ) <= 0);
-            if ( q ) softfloat_sub96M( rem, x, rem );
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( sig32B );
-        expDiff -= 30;
-        for (;;) {
-            x64 = (uint64_t) rem[indexWordHi( 3 )] * recip32;
-            if ( expDiff < 0 ) break;
-            q = (x64 + 0x80000000)>>32;
-            softfloat_remStep96MBy32( rem, 29, x, q, rem );
-            if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
-                softfloat_add96M( rem, x, rem );
-            }
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -29 here.)
-        *--------------------------------------------------------------------*/
-        q = (uint32_t) (x64>>32)>>(~expDiff & 31);
-        softfloat_remStep96MBy32( rem, expDiff + 30, x, q, rem );
-        if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
-            remPtr = rem;
-            altRemPtr = rem2;
-            softfloat_add96M( remPtr, x, altRemPtr );
-            goto selectRem;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    remPtr = rem;
-    altRemPtr = rem2;
-    do {
-        ++q;
-        newRemPtr = altRemPtr;
-        softfloat_sub96M( remPtr, x, newRemPtr );
-        altRemPtr = remPtr;
-        remPtr = newRemPtr;
-    } while ( ! (remPtr[indexWordHi( 3 )] & 0x80000000) );
- selectRem:
-    softfloat_add96M( remPtr, altRemPtr, x );
-    wordMeanRem = x[indexWordHi( 3 )];
-    if (
-        (wordMeanRem & 0x80000000)
-            || (! wordMeanRem && (q & 1) && ! x[indexWord( 3, 0 )]
-                    && ! x[indexWord( 3, 1 )])
-    ) {
-        remPtr = altRemPtr;
-    }
-    if ( remPtr[indexWordHi( 3 )] & 0x80000000 ) {
-        signRem = ! signRem;
-        softfloat_negX96M( remPtr );
-    }
-    softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidExtF80M( zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- copyA:
-    if ( expA < 1 ) {
-        sigA >>= 1 - expA;
-        expA = 0;
-    }
-    zSPtr->signExp = packToExtF80UI64( signRem, expA );
-    zSPtr->signif = sigA;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_rem(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+    *zPtr = extF80_rem( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ extF80M_rem(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiA64;
+    int32_t expA, expB;
+    uint64_t x64;
+    bool signRem;
+    uint64_t sigA;
+    int32_t expDiff;
+    uint32_t rem[3], x[3], sig32B, q, recip32, rem2[3], *remPtr, *altRemPtr;
+    uint32_t *newRemPtr, wordMeanRem;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    expA = expExtF80UI64( uiA64 );
+    expB = expExtF80UI64( bSPtr->signExp );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        if ( expA == 0x7FFF ) goto invalid;
+        /*--------------------------------------------------------------------
+        | If we get here, then argument b is an infinity and `expB' is 0x7FFF;
+        | Doubling `expB' is an easy way to ensure that `expDiff' later is
+        | less than -1, which will result in returning a canonicalized version
+        | of argument a.
+        *--------------------------------------------------------------------*/
+        expB += expB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) expB = 1;
+    x64 = bSPtr->signif;
+    if ( ! (x64 & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! x64 ) goto invalid;
+        expB += softfloat_normExtF80SigM( &x64 );
+    }
+    signRem = signExtF80UI64( uiA64 );
+    if ( ! expA ) expA = 1;
+    sigA = aSPtr->signif;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) {
+            expA = 0;
+            goto copyA;
+        }
+        expA += softfloat_normExtF80SigM( &sigA );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( expDiff < -1 ) goto copyA;
+    rem[indexWord( 3, 2 )] = sigA>>34;
+    rem[indexWord( 3, 1 )] = sigA>>2;
+    rem[indexWord( 3, 0 )] = (uint32_t) sigA<<30;
+    x[indexWord( 3, 0 )] = (uint32_t) x64<<30;
+    sig32B = x64>>32;
+    x64 >>= 2;
+    x[indexWord( 3, 2 )] = x64>>32;
+    x[indexWord( 3, 1 )] = x64;
+    if ( expDiff < 1 ) {
+        if ( expDiff ) {
+            --expB;
+            softfloat_add96M( x, x, x );
+            q = 0;
+        } else {
+            q = (softfloat_compare96M( x, rem ) <= 0);
+            if ( q ) softfloat_sub96M( rem, x, rem );
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( sig32B );
+        expDiff -= 30;
+        for (;;) {
+            x64 = (uint64_t) rem[indexWordHi( 3 )] * recip32;
+            if ( expDiff < 0 ) break;
+            q = (x64 + 0x80000000)>>32;
+            softfloat_remStep96MBy32( rem, 29, x, q, rem );
+            if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
+                softfloat_add96M( rem, x, rem );
+            }
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -29 here.)
+        *--------------------------------------------------------------------*/
+        q = (uint32_t) (x64>>32)>>(~expDiff & 31);
+        softfloat_remStep96MBy32( rem, expDiff + 30, x, q, rem );
+        if ( rem[indexWordHi( 3 )] & 0x80000000 ) {
+            remPtr = rem;
+            altRemPtr = rem2;
+            softfloat_add96M( remPtr, x, altRemPtr );
+            goto selectRem;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    remPtr = rem;
+    altRemPtr = rem2;
+    do {
+        ++q;
+        newRemPtr = altRemPtr;
+        softfloat_sub96M( remPtr, x, newRemPtr );
+        altRemPtr = remPtr;
+        remPtr = newRemPtr;
+    } while ( ! (remPtr[indexWordHi( 3 )] & 0x80000000) );
+ selectRem:
+    softfloat_add96M( remPtr, altRemPtr, x );
+    wordMeanRem = x[indexWordHi( 3 )];
+    if (
+        (wordMeanRem & 0x80000000)
+            || (! wordMeanRem && (q & 1) && ! x[indexWord( 3, 0 )]
+                    && ! x[indexWord( 3, 1 )])
+    ) {
+        remPtr = altRemPtr;
+    }
+    if ( remPtr[indexWordHi( 3 )] & 0x80000000 ) {
+        signRem = ! signRem;
+        softfloat_negX96M( remPtr );
+    }
+    softfloat_normRoundPackMToExtF80M( signRem, expB + 2, remPtr, 80, zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidExtF80M( zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ copyA:
+    if ( expA < 1 ) {
+        sigA >>= 1 - expA;
+        expA = 0;
+    }
+    zSPtr->signExp = packToExtF80UI64( signRem, expA );
+    zSPtr->signif = sigA;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_roundToInt.c b/softfloat/source/extF80M_roundToInt.c
index 2e85729..ff4ae87 100644
--- a/softfloat/source/extF80M_roundToInt.c
+++ b/softfloat/source/extF80M_roundToInt.c
@@ -1,176 +1,176 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_roundToInt(
-     const extFloat80_t *aPtr,
-     uint_fast8_t roundingMode,
-     bool exact,
-     extFloat80_t *zPtr
- )
-{
-
-    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-void
- extF80M_roundToInt(
-     const extFloat80_t *aPtr,
-     uint_fast8_t roundingMode,
-     bool exact,
-     extFloat80_t *zPtr
- )
-{
-    const struct extFloat80M *aSPtr;
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiA64, signUI64;
-    int32_t exp;
-    uint64_t sigA;
-    uint_fast16_t uiZ64;
-    uint64_t sigZ, lastBitMask, roundBitsMask;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
-    exp = expExtF80UI64( uiA64 );
-    sigA = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
-        if ( !sigA ) {
-            uiZ64 = signUI64;
-            sigZ = 0;
-            goto uiZ;
-        }
-        exp += softfloat_normExtF80SigM( &sigA );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp <= 0x3FFE ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0x3FFE ) goto mag1;
-            break;
-         case softfloat_round_min:
-            if ( signUI64 ) goto mag1;
-            break;
-         case softfloat_round_max:
-            if ( !signUI64 ) goto mag1;
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            goto mag1;
-#endif
-        }
-        uiZ64 = signUI64;
-        sigZ = 0;
-        goto uiZ;
-     mag1:
-        uiZ64 = signUI64 | 0x3FFF;
-        sigZ = UINT64_C( 0x8000000000000000 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x403E <= exp ) {
-        if ( exp == 0x7FFF ) {
-            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
-                return;
-            }
-            sigZ = UINT64_C( 0x8000000000000000 );
-        } else {
-            sigZ = sigA;
-        }
-        uiZ64 = signUI64 | exp;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = signUI64 | exp;
-    lastBitMask = (uint64_t) 1<<(0x403E - exp);
-    roundBitsMask = lastBitMask - 1;
-    sigZ = sigA;
-    if ( roundingMode == softfloat_round_near_maxMag ) {
-        sigZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_near_even ) {
-        sigZ += lastBitMask>>1;
-        if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
-    } else if (
-        roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
-    ) {
-        sigZ += roundBitsMask;
-    }
-    sigZ &= ~roundBitsMask;
-    if ( !sigZ ) {
-        ++uiZ64;
-        sigZ = UINT64_C( 0x8000000000000000 );
-    }
-    if ( sigZ != sigA ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = sigZ;
-    return;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_roundToInt(
+     const extFloat80_t *aPtr,
+     uint_fast8_t roundingMode,
+     bool exact,
+     extFloat80_t *zPtr
+ )
+{
+
+    *zPtr = extF80_roundToInt( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+void
+ extF80M_roundToInt(
+     const extFloat80_t *aPtr,
+     uint_fast8_t roundingMode,
+     bool exact,
+     extFloat80_t *zPtr
+ )
+{
+    const struct extFloat80M *aSPtr;
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiA64, signUI64;
+    int32_t exp;
+    uint64_t sigA;
+    uint_fast16_t uiZ64;
+    uint64_t sigZ, lastBitMask, roundBitsMask;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+    exp = expExtF80UI64( uiA64 );
+    sigA = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
+        if ( !sigA ) {
+            uiZ64 = signUI64;
+            sigZ = 0;
+            goto uiZ;
+        }
+        exp += softfloat_normExtF80SigM( &sigA );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp <= 0x3FFE ) {
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0x3FFE ) goto mag1;
+            break;
+         case softfloat_round_min:
+            if ( signUI64 ) goto mag1;
+            break;
+         case softfloat_round_max:
+            if ( !signUI64 ) goto mag1;
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            goto mag1;
+#endif
+        }
+        uiZ64 = signUI64;
+        sigZ = 0;
+        goto uiZ;
+     mag1:
+        uiZ64 = signUI64 | 0x3FFF;
+        sigZ = UINT64_C( 0x8000000000000000 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x403E <= exp ) {
+        if ( exp == 0x7FFF ) {
+            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+                softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+                return;
+            }
+            sigZ = UINT64_C( 0x8000000000000000 );
+        } else {
+            sigZ = sigA;
+        }
+        uiZ64 = signUI64 | exp;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = signUI64 | exp;
+    lastBitMask = (uint64_t) 1<<(0x403E - exp);
+    roundBitsMask = lastBitMask - 1;
+    sigZ = sigA;
+    if ( roundingMode == softfloat_round_near_maxMag ) {
+        sigZ += lastBitMask>>1;
+    } else if ( roundingMode == softfloat_round_near_even ) {
+        sigZ += lastBitMask>>1;
+        if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
+    } else if (
+        roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
+    ) {
+        sigZ += roundBitsMask;
+    }
+    sigZ &= ~roundBitsMask;
+    if ( !sigZ ) {
+        ++uiZ64;
+        sigZ = UINT64_C( 0x8000000000000000 );
+    }
+    if ( sigZ != sigA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = sigZ;
+    return;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_sqrt.c b/softfloat/source/extF80M_sqrt.c
index 7ee91e0..21c15da 100644
--- a/softfloat/source/extF80M_sqrt.c
+++ b/softfloat/source/extF80M_sqrt.c
@@ -1,180 +1,180 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
-{
-
-    *zPtr = extF80_sqrt( *aPtr );
-
-}
-
-#else
-
-void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr;
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiA64, signUI64;
-    int32_t expA;
-    uint64_t rem64;
-    int32_t expZ;
-    uint32_t rem96[3], sig32A, recipSqrt32, sig32Z, q;
-    uint64_t sig64Z, x64;
-    uint32_t rem32, term[4], rem[4], extSigZ[3];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
-    expA = expExtF80UI64( uiA64 );
-    rem64 = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
-            return;
-        }
-        if ( signUI64 ) goto invalid;
-        rem64 = UINT64_C( 0x8000000000000000 );
-        goto copyA;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) expA = 1;
-    if ( ! (rem64 & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! rem64 ) {
-            uiA64 = signUI64;
-            goto copyA;
-        }
-        expA += softfloat_normExtF80SigM( &rem64 );
-    }
-    if ( signUI64 ) goto invalid;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
-    expA &= 1;
-    softfloat_shortShiftLeft64To96M( rem64, 30 - expA, rem96 );
-    sig32A = rem64>>32;
-    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
-    sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
-    if ( expA ) sig32Z >>= 1;
-    rem64 =
-        ((uint64_t) rem96[indexWord( 3, 2 )]<<32 | rem96[indexWord( 3, 1 )])
-            - (uint64_t) sig32Z * sig32Z;
-    rem96[indexWord( 3, 2 )] = rem64>>32;
-    rem96[indexWord( 3, 1 )] = rem64;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
-    sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
-    term[indexWord( 3, 2 )] = 0;
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        x64 = ((uint64_t) sig32Z<<32) + sig64Z;
-        term[indexWord( 3, 1 )] = x64>>32;
-        term[indexWord( 3, 0 )] = x64;
-        softfloat_remStep96MBy32(
-            rem96, 29, term, q, &rem[indexMultiwordHi( 4, 3 )] );
-        rem32 = rem[indexWord( 4, 3 )];
-        if ( ! (rem32 & 0x80000000) ) break;
-        --q;
-        sig64Z -= 1<<3;
-    }
-    rem64 = (uint64_t) rem32<<32 | rem[indexWord( 4, 2 )];
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
-    if ( rem64>>34 ) q += recipSqrt32;
-    x64 = (uint64_t) q<<7;
-    extSigZ[indexWord( 3, 0 )] = x64;
-    x64 = (sig64Z<<1) + (x64>>32);
-    extSigZ[indexWord( 3, 2 )] = x64>>32;
-    extSigZ[indexWord( 3, 1 )] = x64;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (q & 0xFFFFFF) <= 2 ) {
-        q &= ~(uint32_t) 0xFFFF;
-        extSigZ[indexWordLo( 3 )] = q<<7;
-        x64 = sig64Z + (q>>27);
-        term[indexWord( 4, 3 )] = 0;
-        term[indexWord( 4, 2 )] = x64>>32;
-        term[indexWord( 4, 1 )] = x64;
-        term[indexWord( 4, 0 )] = q<<5;
-        rem[indexWord( 4, 0 )] = 0;
-        softfloat_remStep128MBy32( rem, 28, term, q, rem );
-        q = rem[indexWordHi( 4 )];
-        if ( q & 0x80000000 ) {
-            softfloat_sub1X96M( extSigZ );
-        } else {
-            if ( q || rem[indexWord( 4, 1 )] || rem[indexWord( 4, 2 )] ) {
-                extSigZ[indexWordLo( 3 )] |= 1;
-            }
-        }
-    }
-    softfloat_roundPackMToExtF80M(
-        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidExtF80M( zSPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- copyA:
-    zSPtr->signExp = uiA64;
-    zSPtr->signif  = rem64;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+{
+
+    *zPtr = extF80_sqrt( *aPtr );
+
+}
+
+#else
+
+void extF80M_sqrt( const extFloat80_t *aPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr;
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiA64, signUI64;
+    int32_t expA;
+    uint64_t rem64;
+    int32_t expZ;
+    uint32_t rem96[3], sig32A, recipSqrt32, sig32Z, q;
+    uint64_t sig64Z, x64;
+    uint32_t rem32, term[4], rem[4], extSigZ[3];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+    expA = expExtF80UI64( uiA64 );
+    rem64 = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if ( rem64 & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_propagateNaNExtF80M( aSPtr, 0, zSPtr );
+            return;
+        }
+        if ( signUI64 ) goto invalid;
+        rem64 = UINT64_C( 0x8000000000000000 );
+        goto copyA;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) expA = 1;
+    if ( ! (rem64 & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! rem64 ) {
+            uiA64 = signUI64;
+            goto copyA;
+        }
+        expA += softfloat_normExtF80SigM( &rem64 );
+    }
+    if ( signUI64 ) goto invalid;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
+    expA &= 1;
+    softfloat_shortShiftLeft64To96M( rem64, 30 - expA, rem96 );
+    sig32A = rem64>>32;
+    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+    sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
+    if ( expA ) sig32Z >>= 1;
+    rem64 =
+        ((uint64_t) rem96[indexWord( 3, 2 )]<<32 | rem96[indexWord( 3, 1 )])
+            - (uint64_t) sig32Z * sig32Z;
+    rem96[indexWord( 3, 2 )] = rem64>>32;
+    rem96[indexWord( 3, 1 )] = rem64;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+    sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
+    term[indexWord( 3, 2 )] = 0;
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        x64 = ((uint64_t) sig32Z<<32) + sig64Z;
+        term[indexWord( 3, 1 )] = x64>>32;
+        term[indexWord( 3, 0 )] = x64;
+        softfloat_remStep96MBy32(
+            rem96, 29, term, q, &rem[indexMultiwordHi( 4, 3 )] );
+        rem32 = rem[indexWord( 4, 3 )];
+        if ( ! (rem32 & 0x80000000) ) break;
+        --q;
+        sig64Z -= 1<<3;
+    }
+    rem64 = (uint64_t) rem32<<32 | rem[indexWord( 4, 2 )];
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
+    if ( rem64>>34 ) q += recipSqrt32;
+    x64 = (uint64_t) q<<7;
+    extSigZ[indexWord( 3, 0 )] = x64;
+    x64 = (sig64Z<<1) + (x64>>32);
+    extSigZ[indexWord( 3, 2 )] = x64>>32;
+    extSigZ[indexWord( 3, 1 )] = x64;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (q & 0xFFFFFF) <= 2 ) {
+        q &= ~(uint32_t) 0xFFFF;
+        extSigZ[indexWordLo( 3 )] = q<<7;
+        x64 = sig64Z + (q>>27);
+        term[indexWord( 4, 3 )] = 0;
+        term[indexWord( 4, 2 )] = x64>>32;
+        term[indexWord( 4, 1 )] = x64;
+        term[indexWord( 4, 0 )] = q<<5;
+        rem[indexWord( 4, 0 )] = 0;
+        softfloat_remStep128MBy32( rem, 28, term, q, rem );
+        q = rem[indexWordHi( 4 )];
+        if ( q & 0x80000000 ) {
+            softfloat_sub1X96M( extSigZ );
+        } else {
+            if ( q || rem[indexWord( 4, 1 )] || rem[indexWord( 4, 2 )] ) {
+                extSigZ[indexWordLo( 3 )] |= 1;
+            }
+        }
+    }
+    softfloat_roundPackMToExtF80M(
+        0, expZ, extSigZ, extF80_roundingPrecision, zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidExtF80M( zSPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ copyA:
+    zSPtr->signExp = uiA64;
+    zSPtr->signif  = rem64;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_sub.c b/softfloat/source/extF80M_sub.c
index 5d1895c..4f9f1a6 100644
--- a/softfloat/source/extF80M_sub.c
+++ b/softfloat/source/extF80M_sub.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-    const struct extFloat80M *aSPtr, *bSPtr;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    extFloat80_t
-        (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
-#endif
-
-    aSPtr = (const struct extFloat80M *) aPtr;
-    bSPtr = (const struct extFloat80M *) bPtr;
-    uiA64 = aSPtr->signExp;
-    uiA0  = aSPtr->signif;
-    signA = signExtF80UI64( uiA64 );
-    uiB64 = bSPtr->signExp;
-    uiB0  = bSPtr->signif;
-    signB = signExtF80UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
-#else
-
-void
- extF80M_sub(
-     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
-{
-
-    softfloat_addExtF80M(
-        (const struct extFloat80M *) aPtr,
-        (const struct extFloat80M *) bPtr,
-        (struct extFloat80M *) zPtr,
-        true
-    );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ extF80M_sub(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+    const struct extFloat80M *aSPtr, *bSPtr;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    extFloat80_t
+        (*magsFuncPtr)(
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+    aSPtr = (const struct extFloat80M *) aPtr;
+    bSPtr = (const struct extFloat80M *) bPtr;
+    uiA64 = aSPtr->signExp;
+    uiA0  = aSPtr->signif;
+    signA = signExtF80UI64( uiA64 );
+    uiB64 = bSPtr->signExp;
+    uiB0  = bSPtr->signif;
+    signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        *zPtr = softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        *zPtr = softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ extF80M_sub(
+     const extFloat80_t *aPtr, const extFloat80_t *bPtr, extFloat80_t *zPtr )
+{
+
+    softfloat_addExtF80M(
+        (const struct extFloat80M *) aPtr,
+        (const struct extFloat80M *) bPtr,
+        (struct extFloat80M *) zPtr,
+        true
+    );
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_f128M.c b/softfloat/source/extF80M_to_f128M.c
index da81e8d..c0306af 100644
--- a/softfloat/source/extF80M_to_f128M.c
+++ b/softfloat/source/extF80M_to_f128M.c
@@ -1,125 +1,125 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
-{
-
-    *zPtr = extF80_to_f128( *aPtr );
-
-}
-
-#else
-
-void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint32_t *zWPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    struct commonNaN commonNaN;
-    uint32_t uiZ96;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr[indexWord( 4, 0 )] = 0;
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
-            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
-            return;
-        }
-        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) --exp;
-    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sig ) {
-            uiZ96 = packToF128UI96( sign, 0, 0 );
-            goto uiZ;
-        }
-        exp += softfloat_normExtF80SigM( &sig );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr[indexWord( 4, 1 )] = (uint32_t) sig<<17;
-    sig >>= 15;
-    zWPtr[indexWord( 4, 2 )] = sig;
-    if ( exp < 0 ) {
-        zWPtr[indexWordHi( 4 )] = sig>>32;
-        softfloat_shiftRight96M(
-            &zWPtr[indexMultiwordHi( 4, 3 )],
-            -exp,
-            &zWPtr[indexMultiwordHi( 4, 3 )]
-        );
-        exp = 0;
-        sig = (uint64_t) zWPtr[indexWordHi( 4 )]<<32;
-    }
-    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, sig>>32 );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+{
+
+    *zPtr = extF80_to_f128( *aPtr );
+
+}
+
+#else
+
+void extF80M_to_f128M( const extFloat80_t *aPtr, float128_t *zPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint32_t *zWPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    struct commonNaN commonNaN;
+    uint32_t uiZ96;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr[indexWord( 4, 0 )] = 0;
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
+            return;
+        }
+        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) --exp;
+    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sig ) {
+            uiZ96 = packToF128UI96( sign, 0, 0 );
+            goto uiZ;
+        }
+        exp += softfloat_normExtF80SigM( &sig );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr[indexWord( 4, 1 )] = (uint32_t) sig<<17;
+    sig >>= 15;
+    zWPtr[indexWord( 4, 2 )] = sig;
+    if ( exp < 0 ) {
+        zWPtr[indexWordHi( 4 )] = sig>>32;
+        softfloat_shiftRight96M(
+            &zWPtr[indexMultiwordHi( 4, 3 )],
+            -exp,
+            &zWPtr[indexMultiwordHi( 4, 3 )]
+        );
+        exp = 0;
+        sig = (uint64_t) zWPtr[indexWordHi( 4 )]<<32;
+    }
+    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, sig>>32 );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_f16.c b/softfloat/source/extF80M_to_f16.c
index 5ae38d0..7ff56de 100644
--- a/softfloat/source/extF80M_to_f16.c
+++ b/softfloat/source/extF80M_to_f16.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
-{
-
-    return extF80_to_f16( *aPtr );
-
-}
-
-#else
-
-float16_t extF80M_to_f16( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    struct commonNaN commonNaN;
-    uint16_t uiZ, sig16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sig ) {
-            uiZ = packToF16UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        exp += softfloat_normExtF80SigM( &sig );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig16 = softfloat_shortShiftRightJam64( sig, 49 );
-    exp -= 0x3FF1;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x40 ) exp = -0x40;
-    }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+{
+
+    return extF80_to_f16( *aPtr );
+
+}
+
+#else
+
+float16_t extF80M_to_f16( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    struct commonNaN commonNaN;
+    uint16_t uiZ, sig16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sig ) {
+            uiZ = packToF16UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        exp += softfloat_normExtF80SigM( &sig );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig16 = softfloat_shortShiftRightJam64( sig, 49 );
+    exp -= 0x3FF1;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x40 ) exp = -0x40;
+    }
+    return softfloat_roundPackToF16( sign, exp, sig16 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_f32.c b/softfloat/source/extF80M_to_f32.c
index 47cf224..bb1166f 100644
--- a/softfloat/source/extF80M_to_f32.c
+++ b/softfloat/source/extF80M_to_f32.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
-{
-
-    return extF80_to_f32( *aPtr );
-
-}
-
-#else
-
-float32_t extF80M_to_f32( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    struct commonNaN commonNaN;
-    uint32_t uiZ, sig32;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sig ) {
-            uiZ = packToF32UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        exp += softfloat_normExtF80SigM( &sig );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = softfloat_shortShiftRightJam64( sig, 33 );
-    exp -= 0x3F81;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+{
+
+    return extF80_to_f32( *aPtr );
+
+}
+
+#else
+
+float32_t extF80M_to_f32( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    struct commonNaN commonNaN;
+    uint32_t uiZ, sig32;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sig ) {
+            uiZ = packToF32UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        exp += softfloat_normExtF80SigM( &sig );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = softfloat_shortShiftRightJam64( sig, 33 );
+    exp -= 0x3F81;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF32( sign, exp, sig32 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_f64.c b/softfloat/source/extF80M_to_f64.c
index 5f8f4aa..696255f 100644
--- a/softfloat/source/extF80M_to_f64.c
+++ b/softfloat/source/extF80M_to_f64.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
-{
-
-    return extF80_to_f64( *aPtr );
-
-}
-
-#else
-
-float64_t extF80M_to_f64( const extFloat80_t *aPtr )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    struct commonNaN commonNaN;
-    uint64_t uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sig ) {
-            uiZ = packToF64UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        exp += softfloat_normExtF80SigM( &sig );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = softfloat_shortShiftRightJam64( sig, 1 );
-    exp -= 0x3C01;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF64( sign, exp, sig );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+{
+
+    return extF80_to_f64( *aPtr );
+
+}
+
+#else
+
+float64_t extF80M_to_f64( const extFloat80_t *aPtr )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    struct commonNaN commonNaN;
+    uint64_t uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80MToCommonNaN( aSPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! (sig & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sig ) {
+            uiZ = packToF64UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        exp += softfloat_normExtF80SigM( &sig );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = softfloat_shortShiftRightJam64( sig, 1 );
+    exp -= 0x3C01;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF64( sign, exp, sig );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_i32.c b/softfloat/source/extF80M_to_i32.c
index 06394e3..c0464b1 100644
--- a/softfloat/source/extF80M_to_i32.c
+++ b/softfloat/source/extF80M_to_i32.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast32_t
- extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return extF80_to_i32( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-int_fast32_t
- extF80M_to_i32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x4032 - exp;
-    if ( shiftDist <= 0 ) {
-        if ( sig>>32 ) goto invalid;
-        if ( -32 < shiftDist ) {
-            sig <<= -shiftDist;
-        } else {
-            if ( (uint32_t) sig ) goto invalid;
-        }
-    } else {
-        sig = softfloat_shiftRightJam64( sig, shiftDist );
-    }
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
-            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t
+ extF80M_to_i32(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return extF80_to_i32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast32_t
+ extF80M_to_i32(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x4032 - exp;
+    if ( shiftDist <= 0 ) {
+        if ( sig>>32 ) goto invalid;
+        if ( -32 < shiftDist ) {
+            sig <<= -shiftDist;
+        } else {
+            if ( (uint32_t) sig ) goto invalid;
+        }
+    } else {
+        sig = softfloat_shiftRightJam64( sig, shiftDist );
+    }
+    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
+            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_i32_r_minMag.c b/softfloat/source/extF80M_to_i32_r_minMag.c
index 5f5cf59..9a803cc 100644
--- a/softfloat/source/extF80M_to_i32_r_minMag.c
+++ b/softfloat/source/extF80M_to_i32_r_minMag.c
@@ -1,120 +1,120 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-
-    return extF80_to_i32_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    bool sign, raiseInexact;
-    int32_t z;
-    uint64_t shiftedSig;
-    uint32_t absZ;
-    union { uint32_t ui; int32_t i; } u;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! sig && (exp != 0x7FFF) ) return 0;
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        raiseInexact = exact;
-        z = 0;
-    } else {
-        sign = signExtF80UI64( uiA64 );
-        raiseInexact = false;
-        if ( shiftDist < 0 ) {
-            if ( sig>>32 || (shiftDist <= -31) ) goto invalid;
-            shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
-            if ( shiftedSig>>32 ) goto invalid;
-            absZ = shiftedSig;
-        } else {
-            shiftedSig = sig;
-            if ( shiftDist ) shiftedSig >>= shiftDist;
-            if ( shiftedSig>>32 ) goto invalid;
-            absZ = shiftedSig;
-            if ( exact && shiftDist ) {
-                raiseInexact = ((uint64_t) absZ<<shiftDist != sig);
-            }
-        }
-        if ( sign ) {
-            if ( 0x80000000 < absZ ) goto invalid;
-            u.ui = -absZ;
-            z = u.i;
-        } else {
-            if ( 0x80000000 <= absZ ) goto invalid;
-            z = absZ;
-        }
-    }
-    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
-            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+    return extF80_to_i32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    bool sign, raiseInexact;
+    int32_t z;
+    uint64_t shiftedSig;
+    uint32_t absZ;
+    union { uint32_t ui; int32_t i; } u;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! sig && (exp != 0x7FFF) ) return 0;
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        raiseInexact = exact;
+        z = 0;
+    } else {
+        sign = signExtF80UI64( uiA64 );
+        raiseInexact = false;
+        if ( shiftDist < 0 ) {
+            if ( sig>>32 || (shiftDist <= -31) ) goto invalid;
+            shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
+            if ( shiftedSig>>32 ) goto invalid;
+            absZ = shiftedSig;
+        } else {
+            shiftedSig = sig;
+            if ( shiftDist ) shiftedSig >>= shiftDist;
+            if ( shiftedSig>>32 ) goto invalid;
+            absZ = shiftedSig;
+            if ( exact && shiftDist ) {
+                raiseInexact = ((uint64_t) absZ<<shiftDist != sig);
+            }
+        }
+        if ( sign ) {
+            if ( 0x80000000 < absZ ) goto invalid;
+            u.ui = -absZ;
+            z = u.i;
+        } else {
+            if ( 0x80000000 <= absZ ) goto invalid;
+            z = absZ;
+        }
+    }
+    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i32_fromNaN
+            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_i64.c b/softfloat/source/extF80M_to_i64.c
index 1b751dc..2e07207 100644
--- a/softfloat/source/extF80M_to_i64.c
+++ b/softfloat/source/extF80M_to_i64.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast64_t
- extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return extF80_to_i64( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-int_fast64_t
- extF80M_to_i64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    uint32_t extSig[3];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    extSig[indexWord( 3, 2 )] = sig>>32;
-    extSig[indexWord( 3, 1 )] = sig;
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t
+ extF80M_to_i64(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return extF80_to_i64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast64_t
+ extF80M_to_i64(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    uint32_t extSig[3];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist < 0 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    extSig[indexWord( 3, 2 )] = sig>>32;
+    extSig[indexWord( 3, 1 )] = sig;
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_i64_r_minMag.c b/softfloat/source/extF80M_to_i64_r_minMag.c
index ec9b928..07282cd 100644
--- a/softfloat/source/extF80M_to_i64_r_minMag.c
+++ b/softfloat/source/extF80M_to_i64_r_minMag.c
@@ -1,115 +1,115 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-
-    return extF80_to_i64_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    bool sign, raiseInexact;
-    int64_t z;
-    uint64_t absZ;
-    union { uint64_t ui; int64_t i; } u;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! sig && (exp != 0x7FFF) ) return 0;
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        raiseInexact = exact;
-        z = 0;
-    } else {
-        sign = signExtF80UI64( uiA64 );
-        raiseInexact = false;
-        if ( shiftDist < 0 ) {
-            if ( shiftDist <= -63 ) goto invalid;
-            shiftDist = -shiftDist;
-            absZ = sig<<shiftDist;
-            if ( absZ>>shiftDist != sig ) goto invalid;
-        } else {
-            absZ = sig;
-            if ( shiftDist ) absZ >>= shiftDist;
-            if ( exact && shiftDist ) raiseInexact = (absZ<<shiftDist != sig);
-        }
-        if ( sign ) {
-            if ( UINT64_C( 0x8000000000000000 ) < absZ ) goto invalid;
-            u.ui = -absZ;
-            z = u.i;
-        } else {
-            if ( UINT64_C( 0x8000000000000000 ) <= absZ ) goto invalid;
-            z = absZ;
-        }
-    }
-    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i64_fromNaN
-            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+    return extF80_to_i64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    bool sign, raiseInexact;
+    int64_t z;
+    uint64_t absZ;
+    union { uint64_t ui; int64_t i; } u;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! sig && (exp != 0x7FFF) ) return 0;
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        raiseInexact = exact;
+        z = 0;
+    } else {
+        sign = signExtF80UI64( uiA64 );
+        raiseInexact = false;
+        if ( shiftDist < 0 ) {
+            if ( shiftDist <= -63 ) goto invalid;
+            shiftDist = -shiftDist;
+            absZ = sig<<shiftDist;
+            if ( absZ>>shiftDist != sig ) goto invalid;
+        } else {
+            absZ = sig;
+            if ( shiftDist ) absZ >>= shiftDist;
+            if ( exact && shiftDist ) raiseInexact = (absZ<<shiftDist != sig);
+        }
+        if ( sign ) {
+            if ( UINT64_C( 0x8000000000000000 ) < absZ ) goto invalid;
+            u.ui = -absZ;
+            z = u.i;
+        } else {
+            if ( UINT64_C( 0x8000000000000000 ) <= absZ ) goto invalid;
+            z = absZ;
+        }
+    }
+    if ( raiseInexact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ? i64_fromNaN
+            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_ui32.c b/softfloat/source/extF80M_to_ui32.c
index 983a1ee..72579e4 100644
--- a/softfloat/source/extF80M_to_ui32.c
+++ b/softfloat/source/extF80M_to_ui32.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast32_t
- extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return extF80_to_ui32( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-uint_fast32_t
- extF80M_to_ui32(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x4032 - exp;
-    if ( shiftDist <= 0 ) {
-        if ( sig>>32 ) goto invalid;
-        if ( -32 < shiftDist ) {
-            sig <<= -shiftDist;
-        } else {
-            if ( (uint32_t) sig ) goto invalid;
-        }
-    } else {
-        sig = softfloat_shiftRightJam64( sig, shiftDist );
-    }
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            ? ui32_fromNaN
-            : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t
+ extF80M_to_ui32(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return extF80_to_ui32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast32_t
+ extF80M_to_ui32(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x4032 - exp;
+    if ( shiftDist <= 0 ) {
+        if ( sig>>32 ) goto invalid;
+        if ( -32 < shiftDist ) {
+            sig <<= -shiftDist;
+        } else {
+            if ( (uint32_t) sig ) goto invalid;
+        }
+    } else {
+        sig = softfloat_shiftRightJam64( sig, shiftDist );
+    }
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            ? ui32_fromNaN
+            : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_ui32_r_minMag.c b/softfloat/source/extF80M_to_ui32_r_minMag.c
index e28b08d..c09e483 100644
--- a/softfloat/source/extF80M_to_ui32_r_minMag.c
+++ b/softfloat/source/extF80M_to_ui32_r_minMag.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-
-    return extF80_to_ui32_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    bool sign;
-    uint64_t shiftedSig;
-    uint32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! sig && (exp != 0x7FFF) ) return 0;
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( shiftDist < 0 ) {
-        if ( sign || sig>>32 || (shiftDist <= -31) ) goto invalid;
-        shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
-        if ( shiftedSig>>32 ) goto invalid;
-        z = shiftedSig;
-    } else {
-        shiftedSig = sig;
-        if ( shiftDist ) shiftedSig >>= shiftDist;
-        if ( shiftedSig>>32 ) goto invalid;
-        z = shiftedSig;
-        if ( sign && z ) goto invalid;
-        if ( exact && shiftDist && ((uint64_t) z<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            ? ui32_fromNaN
-            : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+    return extF80_to_ui32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    bool sign;
+    uint64_t shiftedSig;
+    uint32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! sig && (exp != 0x7FFF) ) return 0;
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( shiftDist < 0 ) {
+        if ( sign || sig>>32 || (shiftDist <= -31) ) goto invalid;
+        shiftedSig = (uint64_t) (uint32_t) sig<<-shiftDist;
+        if ( shiftedSig>>32 ) goto invalid;
+        z = shiftedSig;
+    } else {
+        shiftedSig = sig;
+        if ( shiftDist ) shiftedSig >>= shiftDist;
+        if ( shiftedSig>>32 ) goto invalid;
+        z = shiftedSig;
+        if ( sign && z ) goto invalid;
+        if ( exact && shiftDist && ((uint64_t) z<<shiftDist != sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            ? ui32_fromNaN
+            : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_ui64.c b/softfloat/source/extF80M_to_ui64.c
index 9d4ef4a..a7ee39f 100644
--- a/softfloat/source/extF80M_to_ui64.c
+++ b/softfloat/source/extF80M_to_ui64.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast64_t
- extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return extF80_to_ui64( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-uint_fast64_t
- extF80M_to_ui64(
-     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    bool sign;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    uint32_t extSig[3];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    extSig[indexWord( 3, 2 )] = sig>>32;
-    extSig[indexWord( 3, 1 )] = sig;
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t
+ extF80M_to_ui64(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return extF80_to_ui64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast64_t
+ extF80M_to_ui64(
+     const extFloat80_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    bool sign;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    uint32_t extSig[3];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist < 0 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    extSig[indexWord( 3, 2 )] = sig>>32;
+    extSig[indexWord( 3, 1 )] = sig;
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80M_to_ui64_r_minMag.c b/softfloat/source/extF80M_to_ui64_r_minMag.c
index 87d8089..bf48390 100644
--- a/softfloat/source/extF80M_to_ui64_r_minMag.c
+++ b/softfloat/source/extF80M_to_ui64_r_minMag.c
@@ -1,108 +1,108 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-
-    return extF80_to_ui64_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
-{
-    const struct extFloat80M *aSPtr;
-    uint_fast16_t uiA64;
-    int32_t exp;
-    uint64_t sig;
-    int32_t shiftDist;
-    bool sign;
-    uint64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aSPtr = (const struct extFloat80M *) aPtr;
-    uiA64 = aSPtr->signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = aSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! sig && (exp != 0x7FFF) ) return 0;
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( shiftDist < 0 ) {
-        if ( sign || (shiftDist <= -63) ) goto invalid;
-        shiftDist = -shiftDist;
-        z = sig<<shiftDist;
-        if ( z>>shiftDist != sig ) goto invalid;
-    } else {
-        z = sig;
-        if ( shiftDist ) z >>= shiftDist;
-        if ( sign && z ) goto invalid;
-        if ( exact && shiftDist && (z<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            ? ui64_fromNaN
-            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+
+    return extF80_to_ui64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *aPtr, bool exact )
+{
+    const struct extFloat80M *aSPtr;
+    uint_fast16_t uiA64;
+    int32_t exp;
+    uint64_t sig;
+    int32_t shiftDist;
+    bool sign;
+    uint64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aSPtr = (const struct extFloat80M *) aPtr;
+    uiA64 = aSPtr->signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = aSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! sig && (exp != 0x7FFF) ) return 0;
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( shiftDist < 0 ) {
+        if ( sign || (shiftDist <= -63) ) goto invalid;
+        shiftDist = -shiftDist;
+        z = sig<<shiftDist;
+        if ( z>>shiftDist != sig ) goto invalid;
+    } else {
+        z = sig;
+        if ( shiftDist ) z >>= shiftDist;
+        if ( sign && z ) goto invalid;
+        if ( exact && shiftDist && (z<<shiftDist != sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            ? ui64_fromNaN
+            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/extF80_add.c b/softfloat/source/extF80_add.c
index 164cb05..c19d25c 100644
--- a/softfloat/source/extF80_add.c
+++ b/softfloat/source/extF80_add.c
@@ -1,80 +1,80 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    extFloat80_t
-        (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    signB = signExtF80UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_add( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    extFloat80_t
+        (*magsFuncPtr)(
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_addMagsExtF80 : softfloat_subMagsExtF80;
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/extF80_div.c b/softfloat/source/extF80_div.c
index 28dfb13..7d649c5 100644
--- a/softfloat/source/extF80_div.c
+++ b/softfloat/source/extF80_div.c
@@ -1,203 +1,203 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-    int_fast32_t expB;
-    uint_fast64_t sigB;
-    bool signZ;
-    struct exp32_sig64 normExpSig;
-    int_fast32_t expZ;
-    struct uint128 rem;
-    uint_fast32_t recip32;
-    uint_fast64_t sigZ;
-    int ix;
-    uint_fast64_t q64;
-    uint_fast32_t q;
-    struct uint128 term;
-    uint_fast64_t sigZExtra;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    expA  = expExtF80UI64( uiA64 );
-    sigA  = uiA0;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    signB = signExtF80UI64( uiB64 );
-    expB  = expExtF80UI64( uiB64 );
-    sigB  = uiB0;
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        if ( expB == 0x7FFF ) {
-            if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) expB = 1;
-    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigB ) {
-            if ( ! sigA ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
-        expB += normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
-        expA += normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x3FFF;
-    if ( sigA < sigB ) {
-        --expZ;
-        rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
-    } else {
-        rem = softfloat_shortShiftLeft128( 0, sigA, 31 );
-    }
-    recip32 = softfloat_approxRecip32_1( sigB>>32 );
-    sigZ = 0;
-    ix = 2;
-    for (;;) {
-        q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
-        q = (q64 + 0x80000000)>>32;
-        --ix;
-        if ( ix < 0 ) break;
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-        term = softfloat_mul64ByShifted32To128( sigB, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            --q;
-            rem = softfloat_add128( rem.v64, rem.v0, sigB>>32, sigB<<32 );
-        }
-        sigZ = (sigZ<<29) + q;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ((q + 1) & 0x3FFFFF) < 2 ) {
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-        term = softfloat_mul64ByShifted32To128( sigB, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        term = softfloat_shortShiftLeft128( 0, sigB, 32 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            --q;
-            rem = softfloat_add128( rem.v64, rem.v0, term.v64, term.v0 );
-        } else if ( softfloat_le128( term.v64, term.v0, rem.v64, rem.v0 ) ) {
-            ++q;
-            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        }
-        if ( rem.v64 | rem.v0 ) q |= 1;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigZ = (sigZ<<6) + (q>>23);
-    sigZExtra = (uint64_t) ((uint_fast64_t) q<<41);
-    return
-        softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
-    uiZ64 = uiZ.v64;
-    uiZ0  = uiZ.v0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ64 = defaultNaNExtF80UI64;
-    uiZ0  = defaultNaNExtF80UI0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
-    uiZ0  = UINT64_C( 0x8000000000000000 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ64 = packToExtF80UI64( signZ, 0 );
-    uiZ0  = 0;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_div( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+    int_fast32_t expB;
+    uint_fast64_t sigB;
+    bool signZ;
+    struct exp32_sig64 normExpSig;
+    int_fast32_t expZ;
+    struct uint128 rem;
+    uint_fast32_t recip32;
+    uint_fast64_t sigZ;
+    int ix;
+    uint_fast64_t q64;
+    uint_fast32_t q;
+    struct uint128 term;
+    uint_fast64_t sigZExtra;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    expA  = expExtF80UI64( uiA64 );
+    sigA  = uiA0;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    signB = signExtF80UI64( uiB64 );
+    expB  = expExtF80UI64( uiB64 );
+    sigB  = uiB0;
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        if ( expB == 0x7FFF ) {
+            if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) expB = 1;
+    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigB ) {
+            if ( ! sigA ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+        expB += normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+        expA += normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x3FFF;
+    if ( sigA < sigB ) {
+        --expZ;
+        rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
+    } else {
+        rem = softfloat_shortShiftLeft128( 0, sigA, 31 );
+    }
+    recip32 = softfloat_approxRecip32_1( sigB>>32 );
+    sigZ = 0;
+    ix = 2;
+    for (;;) {
+        q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
+        q = (q64 + 0x80000000)>>32;
+        --ix;
+        if ( ix < 0 ) break;
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+        term = softfloat_mul64ByShifted32To128( sigB, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            --q;
+            rem = softfloat_add128( rem.v64, rem.v0, sigB>>32, sigB<<32 );
+        }
+        sigZ = (sigZ<<29) + q;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ((q + 1) & 0x3FFFFF) < 2 ) {
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+        term = softfloat_mul64ByShifted32To128( sigB, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        term = softfloat_shortShiftLeft128( 0, sigB, 32 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            --q;
+            rem = softfloat_add128( rem.v64, rem.v0, term.v64, term.v0 );
+        } else if ( softfloat_le128( term.v64, term.v0, rem.v64, rem.v0 ) ) {
+            ++q;
+            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        }
+        if ( rem.v64 | rem.v0 ) q |= 1;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigZ = (sigZ<<6) + (q>>23);
+    sigZExtra = (uint64_t) ((uint_fast64_t) q<<41);
+    return
+        softfloat_roundPackToExtF80(
+            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ64 = uiZ.v64;
+    uiZ0  = uiZ.v0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ64 = defaultNaNExtF80UI64;
+    uiZ0  = defaultNaNExtF80UI0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+    uiZ0  = UINT64_C( 0x8000000000000000 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ64 = packToExtF80UI64( signZ, 0 );
+    uiZ0  = 0;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_eq.c b/softfloat/source/extF80_eq.c
index efcbc37..60f29da 100644
--- a/softfloat/source/extF80_eq.c
+++ b/softfloat/source/extF80_eq.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_eq( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return
-           (uiA0 == uiB0)
-        && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_eq( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    return
+           (uiA0 == uiB0)
+        && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
+
+}
+
diff --git a/softfloat/source/extF80_eq_signaling.c b/softfloat/source/extF80_eq_signaling.c
index 193b191..5a0dfe4 100644
--- a/softfloat/source/extF80_eq_signaling.c
+++ b/softfloat/source/extF80_eq_signaling.c
@@ -1,67 +1,67 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return
-           (uiA0 == uiB0)
-        && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool extF80_eq_signaling( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    return
+           (uiA0 == uiB0)
+        && ((uiA64 == uiB64) || (! uiA0 && ! ((uiA64 | uiB64) & 0x7FFF)));
+
+}
+
diff --git a/softfloat/source/extF80_isSignalingNaN.c b/softfloat/source/extF80_isSignalingNaN.c
index 33d2abd..6086f4b 100644
--- a/softfloat/source/extF80_isSignalingNaN.c
+++ b/softfloat/source/extF80_isSignalingNaN.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_isSignalingNaN( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNExtF80UI( uA.s.signExp, uA.s.signif );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_isSignalingNaN( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNExtF80UI( uA.s.signExp, uA.s.signif );
+
+}
+
diff --git a/softfloat/source/extF80_le.c b/softfloat/source/extF80_le.c
index 4e23c51..2a1ee60 100644
--- a/softfloat/source/extF80_le.c
+++ b/softfloat/source/extF80_le.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_le( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signExtF80UI64( uiA64 );
-    signB = signExtF80UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
-            : ((uiA64 == uiB64) && (uiA0 == uiB0))
-                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_le( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signExtF80UI64( uiA64 );
+    signB = signExtF80UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+            : ((uiA64 == uiB64) && (uiA0 == uiB0))
+                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/extF80_le_quiet.c b/softfloat/source/extF80_le_quiet.c
index 9839e47..5d0c3ae 100644
--- a/softfloat/source/extF80_le_quiet.c
+++ b/softfloat/source/extF80_le_quiet.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signExtF80UI64( uiA64 );
-    signB = signExtF80UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
-            : ((uiA64 == uiB64) && (uiA0 == uiB0))
-                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_le_quiet( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signExtF80UI64( uiA64 );
+    signB = signExtF80UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA || ! (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+            : ((uiA64 == uiB64) && (uiA0 == uiB0))
+                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/extF80_lt.c b/softfloat/source/extF80_lt.c
index a4ac69f..9560d8e 100644
--- a/softfloat/source/extF80_lt.c
+++ b/softfloat/source/extF80_lt.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_lt( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signExtF80UI64( uiA64 );
-    signB = signExtF80UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
-            : ((uiA64 != uiB64) || (uiA0 != uiB0))
-                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_lt( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signExtF80UI64( uiA64 );
+    signB = signExtF80UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+            : ((uiA64 != uiB64) || (uiA0 != uiB0))
+                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/extF80_lt_quiet.c b/softfloat/source/extF80_lt_quiet.c
index 00f4d47..711652c 100644
--- a/softfloat/source/extF80_lt_quiet.c
+++ b/softfloat/source/extF80_lt_quiet.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
-            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signExtF80UI64( uiA64 );
-    signB = signExtF80UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
-            : ((uiA64 != uiB64) || (uiA0 != uiB0))
-                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool extF80_lt_quiet( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    if ( isNaNExtF80UI( uiA64, uiA0 ) || isNaNExtF80UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNExtF80UI( uiA64, uiA0 )
+            || softfloat_isSigNaNExtF80UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signExtF80UI64( uiA64 );
+    signB = signExtF80UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA && (((uiA64 | uiB64) & 0x7FFF) | uiA0 | uiB0)
+            : ((uiA64 != uiB64) || (uiA0 != uiB0))
+                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/extF80_mul.c b/softfloat/source/extF80_mul.c
index 39ce401..c0c50a6 100644
--- a/softfloat/source/extF80_mul.c
+++ b/softfloat/source/extF80_mul.c
@@ -1,158 +1,158 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-    int_fast32_t expB;
-    uint_fast64_t sigB;
-    bool signZ;
-    uint_fast64_t magBits;
-    struct exp32_sig64 normExpSig;
-    int_fast32_t expZ;
-    struct uint128 sig128Z, uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    expA  = expExtF80UI64( uiA64 );
-    sigA  = uiA0;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    signB = signExtF80UI64( uiB64 );
-    expB  = expExtF80UI64( uiB64 );
-    sigB  = uiB0;
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if (
-               (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
-        ) {
-            goto propagateNaN;
-        }
-        magBits = expB | sigB;
-        goto infArg;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        magBits = expA | sigA;
-        goto infArg;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
-        expA += normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) expB = 1;
-    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigB ) goto zero;
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
-        expB += normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FFE;
-    sig128Z = softfloat_mul64To128( sigA, sigB );
-    if ( sig128Z.v64 < UINT64_C( 0x8000000000000000 ) ) {
-        --expZ;
-        sig128Z =
-            softfloat_add128(
-                sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );
-    }
-    return
-        softfloat_roundPackToExtF80(
-            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
-    uiZ64 = uiZ.v64;
-    uiZ0  = uiZ.v0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infArg:
-    if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ64 = defaultNaNExtF80UI64;
-        uiZ0  = defaultNaNExtF80UI0;
-    } else {
-        uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
-        uiZ0  = UINT64_C( 0x8000000000000000 );
-    }
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ64 = packToExtF80UI64( signZ, 0 );
-    uiZ0  = 0;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_mul( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+    int_fast32_t expB;
+    uint_fast64_t sigB;
+    bool signZ;
+    uint_fast64_t magBits;
+    struct exp32_sig64 normExpSig;
+    int_fast32_t expZ;
+    struct uint128 sig128Z, uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    expA  = expExtF80UI64( uiA64 );
+    sigA  = uiA0;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    signB = signExtF80UI64( uiB64 );
+    expB  = expExtF80UI64( uiB64 );
+    sigB  = uiB0;
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if (
+               (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+        ) {
+            goto propagateNaN;
+        }
+        magBits = expB | sigB;
+        goto infArg;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        magBits = expA | sigA;
+        goto infArg;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+        expA += normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) expB = 1;
+    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigB ) goto zero;
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+        expB += normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FFE;
+    sig128Z = softfloat_mul64To128( sigA, sigB );
+    if ( sig128Z.v64 < UINT64_C( 0x8000000000000000 ) ) {
+        --expZ;
+        sig128Z =
+            softfloat_add128(
+                sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );
+    }
+    return
+        softfloat_roundPackToExtF80(
+            signZ, expZ, sig128Z.v64, sig128Z.v0, extF80_roundingPrecision );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ64 = uiZ.v64;
+    uiZ0  = uiZ.v0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infArg:
+    if ( ! magBits ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ64 = defaultNaNExtF80UI64;
+        uiZ0  = defaultNaNExtF80UI0;
+    } else {
+        uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+        uiZ0  = UINT64_C( 0x8000000000000000 );
+    }
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ64 = packToExtF80UI64( signZ, 0 );
+    uiZ0  = 0;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_rem.c b/softfloat/source/extF80_rem.c
index 5ad9775..a2ebaad 100644
--- a/softfloat/source/extF80_rem.c
+++ b/softfloat/source/extF80_rem.c
@@ -1,225 +1,225 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    int_fast32_t expB;
-    uint_fast64_t sigB;
-    struct exp32_sig64 normExpSig;
-    int_fast32_t expDiff;
-    struct uint128 rem, shiftedSigB;
-    uint_fast32_t q, recip32;
-    uint_fast64_t q64;
-    struct uint128 term, altRem, meanRem;
-    bool signRem;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    expA  = expExtF80UI64( uiA64 );
-    sigA  = uiA0;
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    expB  = expExtF80UI64( uiB64 );
-    sigB  = uiB0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if (
-               (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
-        ) {
-            goto propagateNaN;
-        }
-        goto invalid;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        /*--------------------------------------------------------------------
-        | Argument b is an infinity.  Doubling `expB' is an easy way to ensure
-        | that `expDiff' later is less than -1, which will result in returning
-        | a canonicalized version of argument a.
-        *--------------------------------------------------------------------*/
-        expB += expB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) expB = 1;
-    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
-        expB += normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) {
-            expA = 0;
-            goto copyA;
-        }
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
-        expA += normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( expDiff < -1 ) goto copyA;
-    rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
-    shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 32 );
-    if ( expDiff < 1 ) {
-        if ( expDiff ) {
-            --expB;
-            shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 33 );
-            q = 0;
-        } else {
-            q = (sigB <= sigA);
-            if ( q ) {
-                rem =
-                    softfloat_sub128(
-                        rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
-            }
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( sigB>>32 );
-        expDiff -= 30;
-        for (;;) {
-            q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
-            if ( expDiff < 0 ) break;
-            q = (q64 + 0x80000000)>>32;
-            rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-            term = softfloat_mul64ByShifted32To128( sigB, q );
-            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-            if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-                rem =
-                    softfloat_add128(
-                        rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
-            }
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -29 here.)
-        *--------------------------------------------------------------------*/
-        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 );
-        term = softfloat_mul64ByShifted32To128( sigB, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            altRem =
-                softfloat_add128(
-                    rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
-            goto selectRem;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    do {
-        altRem = rem;
-        ++q;
-        rem =
-            softfloat_sub128(
-                rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
-    } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) );
- selectRem:
-    meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 );
-    if (
-        (meanRem.v64 & UINT64_C( 0x8000000000000000 ))
-            || (! (meanRem.v64 | meanRem.v0) && (q & 1))
-    ) {
-        rem = altRem;
-    }
-    signRem = signA;
-    if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-        signRem = ! signRem;
-        rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
-    }
-    return
-        softfloat_normRoundPackToExtF80(
-            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
-    uiZ64 = uiZ.v64;
-    uiZ0  = uiZ.v0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ64 = defaultNaNExtF80UI64;
-    uiZ0  = defaultNaNExtF80UI0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- copyA:
-    if ( expA < 1 ) {
-        sigA >>= 1 - expA;
-        expA = 0;
-    }
-    uiZ64 = packToExtF80UI64( signA, expA );
-    uiZ0  = sigA;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_rem( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    int_fast32_t expB;
+    uint_fast64_t sigB;
+    struct exp32_sig64 normExpSig;
+    int_fast32_t expDiff;
+    struct uint128 rem, shiftedSigB;
+    uint_fast32_t q, recip32;
+    uint_fast64_t q64;
+    struct uint128 term, altRem, meanRem;
+    bool signRem;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    expA  = expExtF80UI64( uiA64 );
+    sigA  = uiA0;
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    expB  = expExtF80UI64( uiB64 );
+    sigB  = uiB0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if (
+               (sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            || ((expB == 0x7FFF) && (sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+        ) {
+            goto propagateNaN;
+        }
+        goto invalid;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        /*--------------------------------------------------------------------
+        | Argument b is an infinity.  Doubling `expB' is an easy way to ensure
+        | that `expDiff' later is less than -1, which will result in returning
+        | a canonicalized version of argument a.
+        *--------------------------------------------------------------------*/
+        expB += expB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) expB = 1;
+    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigB ) goto invalid;
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigB );
+        expB += normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) {
+            expA = 0;
+            goto copyA;
+        }
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+        expA += normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( expDiff < -1 ) goto copyA;
+    rem = softfloat_shortShiftLeft128( 0, sigA, 32 );
+    shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 32 );
+    if ( expDiff < 1 ) {
+        if ( expDiff ) {
+            --expB;
+            shiftedSigB = softfloat_shortShiftLeft128( 0, sigB, 33 );
+            q = 0;
+        } else {
+            q = (sigB <= sigA);
+            if ( q ) {
+                rem =
+                    softfloat_sub128(
+                        rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+            }
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( sigB>>32 );
+        expDiff -= 30;
+        for (;;) {
+            q64 = (uint_fast64_t) (uint32_t) (rem.v64>>2) * recip32;
+            if ( expDiff < 0 ) break;
+            q = (q64 + 0x80000000)>>32;
+            rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+            term = softfloat_mul64ByShifted32To128( sigB, q );
+            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+            if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+                rem =
+                    softfloat_add128(
+                        rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+            }
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -29 here.)
+        *--------------------------------------------------------------------*/
+        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 );
+        term = softfloat_mul64ByShifted32To128( sigB, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            altRem =
+                softfloat_add128(
+                    rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+            goto selectRem;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    do {
+        altRem = rem;
+        ++q;
+        rem =
+            softfloat_sub128(
+                rem.v64, rem.v0, shiftedSigB.v64, shiftedSigB.v0 );
+    } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) );
+ selectRem:
+    meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 );
+    if (
+        (meanRem.v64 & UINT64_C( 0x8000000000000000 ))
+            || (! (meanRem.v64 | meanRem.v0) && (q & 1))
+    ) {
+        rem = altRem;
+    }
+    signRem = signA;
+    if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+        signRem = ! signRem;
+        rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
+    }
+    return
+        softfloat_normRoundPackToExtF80(
+            signRem, rem.v64 | rem.v0 ? expB + 32 : 0, rem.v64, rem.v0, 80 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ64 = uiZ.v64;
+    uiZ0  = uiZ.v0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ64 = defaultNaNExtF80UI64;
+    uiZ0  = defaultNaNExtF80UI0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ copyA:
+    if ( expA < 1 ) {
+        sigA >>= 1 - expA;
+        expA = 0;
+    }
+    uiZ64 = packToExtF80UI64( signA, expA );
+    uiZ0  = sigA;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_roundToInt.c b/softfloat/source/extF80_roundToInt.c
index 6c12d84..8103dae 100644
--- a/softfloat/source/extF80_roundToInt.c
+++ b/softfloat/source/extF80_roundToInt.c
@@ -1,154 +1,154 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t
- extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64, signUI64;
-    int_fast32_t exp;
-    uint_fast64_t sigA;
-    uint_fast16_t uiZ64;
-    uint_fast64_t sigZ;
-    struct exp32_sig64 normExpSig;
-    struct uint128 uiZ;
-    uint_fast64_t lastBitMask, roundBitsMask;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
-    exp = expExtF80UI64( uiA64 );
-    sigA = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
-        if ( !sigA ) {
-            uiZ64 = signUI64;
-            sigZ = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
-        exp += normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x403E <= exp ) {
-        if ( exp == 0x7FFF ) {
-            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
-                uiZ64 = uiZ.v64;
-                sigZ  = uiZ.v0;
-                goto uiZ;
-            }
-            sigZ = UINT64_C( 0x8000000000000000 );
-        } else {
-            sigZ = sigA;
-        }
-        uiZ64 = signUI64 | exp;
-        goto uiZ;
-    }
-    if ( exp <= 0x3FFE ) {
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0x3FFE ) goto mag1;
-            break;
-         case softfloat_round_min:
-            if ( signUI64 ) goto mag1;
-            break;
-         case softfloat_round_max:
-            if ( !signUI64 ) goto mag1;
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            goto mag1;
-#endif
-        }
-        uiZ64 = signUI64;
-        sigZ  = 0;
-        goto uiZ;
-     mag1:
-        uiZ64 = signUI64 | 0x3FFF;
-        sigZ  = UINT64_C( 0x8000000000000000 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = signUI64 | exp;
-    lastBitMask = (uint_fast64_t) 1<<(0x403E - exp);
-    roundBitsMask = lastBitMask - 1;
-    sigZ = sigA;
-    if ( roundingMode == softfloat_round_near_maxMag ) {
-        sigZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_near_even ) {
-        sigZ += lastBitMask>>1;
-        if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
-    } else if (
-        roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
-    ) {
-        sigZ += roundBitsMask;
-    }
-    sigZ &= ~roundBitsMask;
-    if ( !sigZ ) {
-        ++uiZ64;
-        sigZ = UINT64_C( 0x8000000000000000 );
-    }
-    if ( sigZ != sigA ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif = sigZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t
+ extF80_roundToInt( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64, signUI64;
+    int_fast32_t exp;
+    uint_fast64_t sigA;
+    uint_fast16_t uiZ64;
+    uint_fast64_t sigZ;
+    struct exp32_sig64 normExpSig;
+    struct uint128 uiZ;
+    uint_fast64_t lastBitMask, roundBitsMask;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    signUI64 = uiA64 & packToExtF80UI64( 1, 0 );
+    exp = expExtF80UI64( uiA64 );
+    sigA = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( !(sigA & UINT64_C( 0x8000000000000000 )) && (exp != 0x7FFF) ) {
+        if ( !sigA ) {
+            uiZ64 = signUI64;
+            sigZ = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+        exp += normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x403E <= exp ) {
+        if ( exp == 0x7FFF ) {
+            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+                uiZ = softfloat_propagateNaNExtF80UI( uiA64, sigA, 0, 0 );
+                uiZ64 = uiZ.v64;
+                sigZ  = uiZ.v0;
+                goto uiZ;
+            }
+            sigZ = UINT64_C( 0x8000000000000000 );
+        } else {
+            sigZ = sigA;
+        }
+        uiZ64 = signUI64 | exp;
+        goto uiZ;
+    }
+    if ( exp <= 0x3FFE ) {
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !(sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0x3FFE ) goto mag1;
+            break;
+         case softfloat_round_min:
+            if ( signUI64 ) goto mag1;
+            break;
+         case softfloat_round_max:
+            if ( !signUI64 ) goto mag1;
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            goto mag1;
+#endif
+        }
+        uiZ64 = signUI64;
+        sigZ  = 0;
+        goto uiZ;
+     mag1:
+        uiZ64 = signUI64 | 0x3FFF;
+        sigZ  = UINT64_C( 0x8000000000000000 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = signUI64 | exp;
+    lastBitMask = (uint_fast64_t) 1<<(0x403E - exp);
+    roundBitsMask = lastBitMask - 1;
+    sigZ = sigA;
+    if ( roundingMode == softfloat_round_near_maxMag ) {
+        sigZ += lastBitMask>>1;
+    } else if ( roundingMode == softfloat_round_near_even ) {
+        sigZ += lastBitMask>>1;
+        if ( !(sigZ & roundBitsMask) ) sigZ &= ~lastBitMask;
+    } else if (
+        roundingMode == (signUI64 ? softfloat_round_min : softfloat_round_max)
+    ) {
+        sigZ += roundBitsMask;
+    }
+    sigZ &= ~roundBitsMask;
+    if ( !sigZ ) {
+        ++uiZ64;
+        sigZ = UINT64_C( 0x8000000000000000 );
+    }
+    if ( sigZ != sigA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) sigZ |= lastBitMask;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif = sigZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_sqrt.c b/softfloat/source/extF80_sqrt.c
index af8c496..5d328a0 100644
--- a/softfloat/source/extF80_sqrt.c
+++ b/softfloat/source/extF80_sqrt.c
@@ -1,176 +1,176 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_sqrt( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    struct exp32_sig64 normExpSig;
-    int_fast32_t expZ;
-    uint_fast32_t sig32A, recipSqrt32, sig32Z;
-    struct uint128 rem;
-    uint_fast64_t q, x64, sigZ;
-    struct uint128 y, term;
-    uint_fast64_t sigZExtra;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    expA  = expExtF80UI64( uiA64 );
-    sigA  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
-            uiZ64 = uiZ.v64;
-            uiZ0  = uiZ.v0;
-            goto uiZ;
-        }
-        if ( ! signA ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signA ) {
-        if ( ! sigA ) goto zero;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
-        expA += normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    | (`sig32Z' is guaranteed to be a lower bound on the square root of
-    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
-    | `sigA'.)
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
-    expA &= 1;
-    sig32A = sigA>>32;
-    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
-    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
-    if ( expA ) {
-        sig32Z >>= 1;
-        rem = softfloat_shortShiftLeft128( 0, sigA, 61 );
-    } else {
-        rem = softfloat_shortShiftLeft128( 0, sigA, 62 );
-    }
-    rem.v64 -= (uint_fast64_t) sig32Z * sig32Z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32;
-    x64 = (uint_fast64_t) sig32Z<<32;
-    sigZ = x64 + (q<<3);
-    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        term = softfloat_mul64ByShifted32To128( x64 + sigZ, q );
-        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
-        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
-        --q;
-        sigZ -= 1<<3;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = (((rem.v64>>2) * recipSqrt32)>>32) + 2;
-    x64 = sigZ;
-    sigZ = (sigZ<<1) + (q>>25);
-    sigZExtra = (uint64_t) (q<<39);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (q & 0xFFFFFF) <= 2 ) {
-        q &= ~(uint_fast64_t) 0xFFFF;
-        sigZExtra = (uint64_t) (q<<39);
-        term = softfloat_mul64ByShifted32To128( x64 + (q>>27), q );
-        x64 = (uint32_t) (q<<5) * (uint_fast64_t) (uint32_t) q;
-        term = softfloat_add128( term.v64, term.v0, 0, x64 );
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 28 );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            if ( ! sigZExtra ) --sigZ;
-            --sigZExtra;
-        } else {
-            if ( rem.v64 | rem.v0 ) sigZExtra |= 1;
-        }
-    }
-    return
-        softfloat_roundPackToExtF80(
-            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ64 = defaultNaNExtF80UI64;
-    uiZ0  = defaultNaNExtF80UI0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ64 = packToExtF80UI64( signA, 0 );
-    uiZ0  = 0;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_sqrt( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    struct exp32_sig64 normExpSig;
+    int_fast32_t expZ;
+    uint_fast32_t sig32A, recipSqrt32, sig32Z;
+    struct uint128 rem;
+    uint_fast64_t q, x64, sigZ;
+    struct uint128 y, term;
+    uint_fast64_t sigZExtra;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    expA  = expExtF80UI64( uiA64 );
+    sigA  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, 0, 0 );
+            uiZ64 = uiZ.v64;
+            uiZ0  = uiZ.v0;
+            goto uiZ;
+        }
+        if ( ! signA ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signA ) {
+        if ( ! sigA ) goto zero;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalExtF80Sig( sigA );
+        expA += normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    | (`sig32Z' is guaranteed to be a lower bound on the square root of
+    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+    | `sigA'.)
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x3FFF)>>1) + 0x3FFF;
+    expA &= 1;
+    sig32A = sigA>>32;
+    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
+    if ( expA ) {
+        sig32Z >>= 1;
+        rem = softfloat_shortShiftLeft128( 0, sigA, 61 );
+    } else {
+        rem = softfloat_shortShiftLeft128( 0, sigA, 62 );
+    }
+    rem.v64 -= (uint_fast64_t) sig32Z * sig32Z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32;
+    x64 = (uint_fast64_t) sig32Z<<32;
+    sigZ = x64 + (q<<3);
+    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        term = softfloat_mul64ByShifted32To128( x64 + sigZ, q );
+        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
+        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
+        --q;
+        sigZ -= 1<<3;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = (((rem.v64>>2) * recipSqrt32)>>32) + 2;
+    x64 = sigZ;
+    sigZ = (sigZ<<1) + (q>>25);
+    sigZExtra = (uint64_t) (q<<39);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (q & 0xFFFFFF) <= 2 ) {
+        q &= ~(uint_fast64_t) 0xFFFF;
+        sigZExtra = (uint64_t) (q<<39);
+        term = softfloat_mul64ByShifted32To128( x64 + (q>>27), q );
+        x64 = (uint32_t) (q<<5) * (uint_fast64_t) (uint32_t) q;
+        term = softfloat_add128( term.v64, term.v0, 0, x64 );
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 28 );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            if ( ! sigZExtra ) --sigZ;
+            --sigZExtra;
+        } else {
+            if ( rem.v64 | rem.v0 ) sigZExtra |= 1;
+        }
+    }
+    return
+        softfloat_roundPackToExtF80(
+            0, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ64 = defaultNaNExtF80UI64;
+    uiZ0  = defaultNaNExtF80UI0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ64 = packToExtF80UI64( signA, 0 );
+    uiZ0  = 0;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_sub.c b/softfloat/source/extF80_sub.c
index 770c756..494d316 100644
--- a/softfloat/source/extF80_sub.c
+++ b/softfloat/source/extF80_sub.c
@@ -1,80 +1,80 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool signA;
-    union { struct extFloat80M s; extFloat80_t f; } uB;
-    uint_fast16_t uiB64;
-    uint_fast64_t uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    extFloat80_t
-        (*magsFuncPtr)(
-            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    signA = signExtF80UI64( uiA64 );
-    uB.f = b;
-    uiB64 = uB.s.signExp;
-    uiB0  = uB.s.signif;
-    signB = signExtF80UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t extF80_sub( extFloat80_t a, extFloat80_t b )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool signA;
+    union { struct extFloat80M s; extFloat80_t f; } uB;
+    uint_fast16_t uiB64;
+    uint_fast64_t uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    extFloat80_t
+        (*magsFuncPtr)(
+            uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    signA = signExtF80UI64( uiA64 );
+    uB.f = b;
+    uiB64 = uB.s.signExp;
+    uiB0  = uB.s.signif;
+    signB = signExtF80UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_subMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        return softfloat_addMagsExtF80( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_subMagsExtF80 : softfloat_addMagsExtF80;
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/extF80_to_f128.c b/softfloat/source/extF80_to_f128.c
index 4de90ae..7fbc9cb 100644
--- a/softfloat/source/extF80_to_f128.c
+++ b/softfloat/source/extF80_to_f128.c
@@ -1,75 +1,75 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t extF80_to_f128( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    uint_fast16_t exp;
-    uint_fast64_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    bool sign;
-    struct uint128 frac128;
-    union ui128_f128 uZ;
-
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    exp = expExtF80UI64( uiA64 );
-    frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
-    if ( (exp == 0x7FFF) && frac ) {
-        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
-        uiZ = softfloat_commonNaNToF128UI( &commonNaN );
-    } else {
-        sign = signExtF80UI64( uiA64 );
-        frac128 = softfloat_shortShiftLeft128( 0, frac, 49 );
-        uiZ.v64 = packToF128UI64( sign, exp, frac128.v64 );
-        uiZ.v0  = frac128.v0;
-    }
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t extF80_to_f128( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    uint_fast16_t exp;
+    uint_fast64_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    bool sign;
+    struct uint128 frac128;
+    union ui128_f128 uZ;
+
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    exp = expExtF80UI64( uiA64 );
+    frac = uiA0 & UINT64_C( 0x7FFFFFFFFFFFFFFF );
+    if ( (exp == 0x7FFF) && frac ) {
+        softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+        uiZ = softfloat_commonNaNToF128UI( &commonNaN );
+    } else {
+        sign = signExtF80UI64( uiA64 );
+        frac128 = softfloat_shortShiftLeft128( 0, frac, 49 );
+        uiZ.v64 = packToF128UI64( sign, exp, frac128.v64 );
+        uiZ.v0  = frac128.v0;
+    }
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_to_f16.c b/softfloat/source/extF80_to_f16.c
index 5919403..ca5050f 100644
--- a/softfloat/source/extF80_to_f16.c
+++ b/softfloat/source/extF80_to_f16.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t extF80_to_f16( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ, sig16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig16 = softfloat_shortShiftRightJam64( sig, 49 );
-    if ( ! (exp | sig16) ) {
-        uiZ = packToF16UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3FF1;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x40 ) exp = -0x40;
-    }
-    return softfloat_roundPackToF16( sign, exp, sig16 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t extF80_to_f16( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ, sig16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig16 = softfloat_shortShiftRightJam64( sig, 49 );
+    if ( ! (exp | sig16) ) {
+        uiZ = packToF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3FF1;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x40 ) exp = -0x40;
+    }
+    return softfloat_roundPackToF16( sign, exp, sig16 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_to_f32.c b/softfloat/source/extF80_to_f32.c
index 77fcfdc..357f56e 100644
--- a/softfloat/source/extF80_to_f32.c
+++ b/softfloat/source/extF80_to_f32.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t extF80_to_f32( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    struct commonNaN commonNaN;
-    uint_fast32_t uiZ, sig32;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = softfloat_shortShiftRightJam64( sig, 33 );
-    if ( ! (exp | sig32) ) {
-        uiZ = packToF32UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3F81;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF32( sign, exp, sig32 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t extF80_to_f32( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    struct commonNaN commonNaN;
+    uint_fast32_t uiZ, sig32;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = softfloat_shortShiftRightJam64( sig, 33 );
+    if ( ! (exp | sig32) ) {
+        uiZ = packToF32UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3F81;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF32( sign, exp, sig32 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_to_f64.c b/softfloat/source/extF80_to_f64.c
index 410d662..c387399 100644
--- a/softfloat/source/extF80_to_f64.c
+++ b/softfloat/source/extF80_to_f64.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t extF80_to_f64( extFloat80_t a )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    uint_fast64_t uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    struct commonNaN commonNaN;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    uiA0  = uA.s.signif;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! (exp | sig) ) {
-        uiZ = packToF64UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = softfloat_shortShiftRightJam64( sig, 1 );
-    exp -= 0x3C01;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF64( sign, exp, sig );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t extF80_to_f64( extFloat80_t a )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    uint_fast64_t uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    struct commonNaN commonNaN;
+    uint_fast64_t uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    uiA0  = uA.s.signif;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! (exp | sig) ) {
+        uiZ = packToF64UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            softfloat_extF80UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = softfloat_shortShiftRightJam64( sig, 1 );
+    exp -= 0x3C01;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF64( sign, exp, sig );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/extF80_to_i32.c b/softfloat/source/extF80_to_i32.c
index 9acdc3c..549ca76 100644
--- a/softfloat/source/extF80_to_i32.c
+++ b/softfloat/source/extF80_to_i32.c
@@ -1,83 +1,83 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t
- extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
-#if (i32_fromNaN == i32_fromPosOverflow)
-        sign = 0;
-#elif (i32_fromNaN == i32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return i32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x4032 - exp;
-    if ( shiftDist <= 0 ) shiftDist = 1;
-    sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t
+ extF80_to_i32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+        sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return i32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x4032 - exp;
+    if ( shiftDist <= 0 ) shiftDist = 1;
+    sig = softfloat_shiftRightJam64( sig, shiftDist );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/extF80_to_i32_r_minMag.c b/softfloat/source/extF80_to_i32_r_minMag.c
index 0322467..2b7b9e2 100644
--- a/softfloat/source/extF80_to_i32_r_minMag.c
+++ b/softfloat/source/extF80_to_i32_r_minMag.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    bool sign;
-    int_fast32_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( shiftDist < 33 ) {
-        if (
-            (uiA64 == packToExtF80UI64( 1, 0x401E ))
-                && (sig < UINT64_C( 0x8000000100000000 ))
-        ) {
-            if ( exact && (sig & UINT64_C( 0x00000000FFFFFFFF )) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return -0x7FFFFFFF - 1;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    absZ = sig>>shiftDist;
-    if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t a, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    bool sign;
+    int_fast32_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( shiftDist < 33 ) {
+        if (
+            (uiA64 == packToExtF80UI64( 1, 0x401E ))
+                && (sig < UINT64_C( 0x8000000100000000 ))
+        ) {
+            if ( exact && (sig & UINT64_C( 0x00000000FFFFFFFF )) ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return -0x7FFFFFFF - 1;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    absZ = sig>>shiftDist;
+    if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/extF80_to_i64.c b/softfloat/source/extF80_to_i64.c
index ba307a6..35f55de 100644
--- a/softfloat/source/extF80_to_i64.c
+++ b/softfloat/source/extF80_to_i64.c
@@ -1,89 +1,89 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t
- extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    uint_fast64_t sigExtra;
-    struct uint64_extra sig64Extra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist <= 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( shiftDist ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            return
-                (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                    ? i64_fromNaN
-                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sigExtra = 0;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
-        sig = sig64Extra.v;
-        sigExtra = sig64Extra.extra;
-    }
-    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t
+ extF80_to_i64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    uint_fast64_t sigExtra;
+    struct uint64_extra sig64Extra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist <= 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( shiftDist ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            return
+                (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                    ? i64_fromNaN
+                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sigExtra = 0;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+        sig = sig64Extra.v;
+        sigExtra = sig64Extra.extra;
+    }
+    return softfloat_roundToI64( sign, sig, sigExtra, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/extF80_to_i64_r_minMag.c b/softfloat/source/extF80_to_i64_r_minMag.c
index 8871d01..215876d 100644
--- a/softfloat/source/extF80_to_i64_r_minMag.c
+++ b/softfloat/source/extF80_to_i64_r_minMag.c
@@ -1,94 +1,94 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    bool sign;
-    int_fast64_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( shiftDist <= 0 ) {
-        if (
-            (uiA64 == packToExtF80UI64( 1, 0x403E ))
-                && (sig == UINT64_C( 0x8000000000000000 ))
-        ) {
-            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    absZ = sig>>shiftDist;
-    if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t a, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    bool sign;
+    int_fast64_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( shiftDist <= 0 ) {
+        if (
+            (uiA64 == packToExtF80UI64( 1, 0x403E ))
+                && (sig == UINT64_C( 0x8000000000000000 ))
+        ) {
+            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    absZ = sig>>shiftDist;
+    if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/extF80_to_ui32.c b/softfloat/source/extF80_to_ui32.c
index 5812977..d121c48 100644
--- a/softfloat/source/extF80_to_ui32.c
+++ b/softfloat/source/extF80_to_ui32.c
@@ -1,83 +1,83 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t
- extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
-#if (ui32_fromNaN == ui32_fromPosOverflow)
-        sign = 0;
-#elif (ui32_fromNaN == ui32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return ui32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x4032 - exp;
-    if ( shiftDist <= 0 ) shiftDist = 1;
-    sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t
+ extF80_to_ui32( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+        sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return ui32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x4032 - exp;
+    if ( shiftDist <= 0 ) shiftDist = 1;
+    sig = softfloat_shiftRightJam64( sig, shiftDist );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/extF80_to_ui32_r_minMag.c b/softfloat/source/extF80_to_ui32_r_minMag.c
index be2c53b..ad30483 100644
--- a/softfloat/source/extF80_to_ui32_r_minMag.c
+++ b/softfloat/source/extF80_to_ui32_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    bool sign;
-    uint_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( sign || (shiftDist < 32) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    z = sig>>shiftDist;
-    if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t a, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    bool sign;
+    uint_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( sign || (shiftDist < 32) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    z = sig>>shiftDist;
+    if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/extF80_to_ui64.c b/softfloat/source/extF80_to_ui64.c
index 490b26a..a81bbd1 100644
--- a/softfloat/source/extF80_to_ui64.c
+++ b/softfloat/source/extF80_to_ui64.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t
- extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    uint_fast64_t sigExtra;
-    struct uint64_extra sig64Extra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    sign = signExtF80UI64( uiA64 );
-    exp  = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigExtra = 0;
-    if ( shiftDist ) {
-        sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
-        sig = sig64Extra.v;
-        sigExtra = sig64Extra.extra;
-    }
-    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t
+ extF80_to_ui64( extFloat80_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    uint_fast64_t sigExtra;
+    struct uint64_extra sig64Extra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    sign = signExtF80UI64( uiA64 );
+    exp  = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist < 0 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigExtra = 0;
+    if ( shiftDist ) {
+        sig64Extra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+        sig = sig64Extra.v;
+        sigExtra = sig64Extra.extra;
+    }
+    return softfloat_roundToUI64( sign, sig, sigExtra, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/extF80_to_ui64_r_minMag.c b/softfloat/source/extF80_to_ui64_r_minMag.c
index eca688c..65adfe7 100644
--- a/softfloat/source/extF80_to_ui64_r_minMag.c
+++ b/softfloat/source/extF80_to_ui64_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
-{
-    union { struct extFloat80M s; extFloat80_t f; } uA;
-    uint_fast16_t uiA64;
-    int_fast32_t exp;
-    uint_fast64_t sig;
-    int_fast32_t shiftDist;
-    bool sign;
-    uint_fast64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.s.signExp;
-    exp = expExtF80UI64( uiA64 );
-    sig = uA.s.signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signExtF80UI64( uiA64 );
-    if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    z = sig>>shiftDist;
-    if ( exact && (z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t a, bool exact )
+{
+    union { struct extFloat80M s; extFloat80_t f; } uA;
+    uint_fast16_t uiA64;
+    int_fast32_t exp;
+    uint_fast64_t sig;
+    int_fast32_t shiftDist;
+    bool sign;
+    uint_fast64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.s.signExp;
+    exp = expExtF80UI64( uiA64 );
+    sig = uA.s.signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signExtF80UI64( uiA64 );
+    if ( sign || (shiftDist < 0) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && (sig & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    z = sig>>shiftDist;
+    if ( exact && (z<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/f128M_add.c b/softfloat/source/f128M_add.c
index 3062bee..f39b1ff 100644
--- a/softfloat/source/f128M_add.c
+++ b/softfloat/source/f128M_add.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-    const uint64_t *aWPtr, *bWPtr;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float128_t
-        (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    aWPtr = (const uint64_t *) aPtr;
-    bWPtr = (const uint64_t *) bPtr;
-    uiA64 = aWPtr[indexWord( 2, 1 )];
-    uiA0  = aWPtr[indexWord( 2, 0 )];
-    signA = signF128UI64( uiA64 );
-    uiB64 = bWPtr[indexWord( 2, 1 )];
-    uiB0  = bWPtr[indexWord( 2, 0 )];
-    signB = signF128UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
-#else
-
-void
- f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-
-    softfloat_addF128M(
-        (const uint32_t *) aPtr,
-        (const uint32_t *) bPtr,
-        (uint32_t *) zPtr,
-        false
-    );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+    const uint64_t *aWPtr, *bWPtr;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float128_t
+        (*magsFuncPtr)(
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    aWPtr = (const uint64_t *) aPtr;
+    bWPtr = (const uint64_t *) bPtr;
+    uiA64 = aWPtr[indexWord( 2, 1 )];
+    uiA0  = aWPtr[indexWord( 2, 0 )];
+    signA = signF128UI64( uiA64 );
+    uiB64 = bWPtr[indexWord( 2, 1 )];
+    uiB0  = bWPtr[indexWord( 2, 0 )];
+    signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ f128M_add( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+    softfloat_addF128M(
+        (const uint32_t *) aPtr,
+        (const uint32_t *) bPtr,
+        (uint32_t *) zPtr,
+        false
+    );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_div.c b/softfloat/source/f128M_div.c
index b443548..8355dc2 100644
--- a/softfloat/source/f128M_div.c
+++ b/softfloat/source/f128M_div.c
@@ -1,187 +1,187 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-
-    *zPtr = f128_div( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t *zWPtr, uiA96;
-    bool signA;
-    int32_t expA;
-    uint32_t uiB96;
-    bool signB;
-    int32_t expB;
-    bool signZ;
-    uint32_t y[5], sigB[4];
-    int32_t expZ;
-    uint32_t recip32;
-    int ix;
-    uint64_t q64;
-    uint32_t q, qs[3], uiZ96;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    expA  = expF128UI96( uiA96 );
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    signB = signF128UI96( uiB96 );
-    expB  = expF128UI96( uiB96 );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
-        if ( expA == 0x7FFF ) {
-            if ( expB == 0x7FFF ) goto invalid;
-            goto infinity;
-        }
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = softfloat_shiftNormSigF128M( aWPtr, 13, y );
-    expB = softfloat_shiftNormSigF128M( bWPtr, 13, sigB );
-    if ( expA == -128 ) {
-        if ( expB == -128 ) goto invalid;
-        goto zero;
-    }
-    if ( expB == -128 ) {
-        softfloat_raiseFlags( softfloat_flag_infinite );
-        goto infinity;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x3FFE;
-    if ( softfloat_compare128M( y, sigB ) < 0 ) {
-        --expZ;
-        softfloat_add128M( y, y, y );
-    }
-    recip32 =
-        softfloat_approxRecip32_1(
-            ((uint64_t) sigB[indexWord( 4, 3 )]<<32 | sigB[indexWord( 4, 2 )])
-                >>30
-        );
-    ix = 3;
-    for (;;) {
-        q64 = (uint64_t) y[indexWordHi( 4 )] * recip32;
-        q = (q64 + 0x80000000)>>32;
-        --ix;
-        if ( ix < 0 ) break;
-        softfloat_remStep128MBy32( y, 29, sigB, q, y );
-        if ( y[indexWordHi( 4 )] & 0x80000000 ) {
-            --q;
-            softfloat_add128M( y, sigB, y );
-        }
-        qs[ix] = q;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ((q + 1) & 7) < 2 ) {
-        softfloat_remStep128MBy32( y, 29, sigB, q, y );
-        if ( y[indexWordHi( 4 )] & 0x80000000 ) {
-            --q;
-            softfloat_add128M( y, sigB, y );
-        } else if ( softfloat_compare128M( sigB, y ) <= 0 ) {
-            ++q;
-            softfloat_sub128M( y, sigB, y );
-        }
-        if (
-            y[indexWordLo( 4 )] || y[indexWord( 4, 1 )]
-                || (y[indexWord( 4, 2 )] | y[indexWord( 4, 3 )])
-        ) {
-            q |= 1;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q64 = (uint64_t) q<<28;
-    y[indexWord( 5, 0 )] = q64;
-    q64 = ((uint64_t) qs[0]<<25) + (q64>>32);
-    y[indexWord( 5, 1 )] = q64;
-    q64 = ((uint64_t) qs[1]<<22) + (q64>>32);
-    y[indexWord( 5, 2 )] = q64;
-    q64 = ((uint64_t) qs[2]<<19) + (q64>>32);
-    y[indexWord( 5, 3 )] = q64;
-    y[indexWord( 5, 4 )] = q64>>32;
-    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidF128M( zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
-    goto uiZ96;
- zero:
-    uiZ96 = packToF128UI96( signZ, 0, 0 );
- uiZ96:
-    zWPtr[indexWordHi( 4 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+    *zPtr = f128_div( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_div( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t *zWPtr, uiA96;
+    bool signA;
+    int32_t expA;
+    uint32_t uiB96;
+    bool signB;
+    int32_t expB;
+    bool signZ;
+    uint32_t y[5], sigB[4];
+    int32_t expZ;
+    uint32_t recip32;
+    int ix;
+    uint64_t q64;
+    uint32_t q, qs[3], uiZ96;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    expA  = expF128UI96( uiA96 );
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    signB = signF128UI96( uiB96 );
+    expB  = expF128UI96( uiB96 );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( expA == 0x7FFF ) {
+            if ( expB == 0x7FFF ) goto invalid;
+            goto infinity;
+        }
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = softfloat_shiftNormSigF128M( aWPtr, 13, y );
+    expB = softfloat_shiftNormSigF128M( bWPtr, 13, sigB );
+    if ( expA == -128 ) {
+        if ( expB == -128 ) goto invalid;
+        goto zero;
+    }
+    if ( expB == -128 ) {
+        softfloat_raiseFlags( softfloat_flag_infinite );
+        goto infinity;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x3FFE;
+    if ( softfloat_compare128M( y, sigB ) < 0 ) {
+        --expZ;
+        softfloat_add128M( y, y, y );
+    }
+    recip32 =
+        softfloat_approxRecip32_1(
+            ((uint64_t) sigB[indexWord( 4, 3 )]<<32 | sigB[indexWord( 4, 2 )])
+                >>30
+        );
+    ix = 3;
+    for (;;) {
+        q64 = (uint64_t) y[indexWordHi( 4 )] * recip32;
+        q = (q64 + 0x80000000)>>32;
+        --ix;
+        if ( ix < 0 ) break;
+        softfloat_remStep128MBy32( y, 29, sigB, q, y );
+        if ( y[indexWordHi( 4 )] & 0x80000000 ) {
+            --q;
+            softfloat_add128M( y, sigB, y );
+        }
+        qs[ix] = q;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ((q + 1) & 7) < 2 ) {
+        softfloat_remStep128MBy32( y, 29, sigB, q, y );
+        if ( y[indexWordHi( 4 )] & 0x80000000 ) {
+            --q;
+            softfloat_add128M( y, sigB, y );
+        } else if ( softfloat_compare128M( sigB, y ) <= 0 ) {
+            ++q;
+            softfloat_sub128M( y, sigB, y );
+        }
+        if (
+            y[indexWordLo( 4 )] || y[indexWord( 4, 1 )]
+                || (y[indexWord( 4, 2 )] | y[indexWord( 4, 3 )])
+        ) {
+            q |= 1;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q64 = (uint64_t) q<<28;
+    y[indexWord( 5, 0 )] = q64;
+    q64 = ((uint64_t) qs[0]<<25) + (q64>>32);
+    y[indexWord( 5, 1 )] = q64;
+    q64 = ((uint64_t) qs[1]<<22) + (q64>>32);
+    y[indexWord( 5, 2 )] = q64;
+    q64 = ((uint64_t) qs[2]<<19) + (q64>>32);
+    y[indexWord( 5, 3 )] = q64;
+    y[indexWord( 5, 4 )] = q64>>32;
+    softfloat_roundPackMToF128M( signZ, expZ, y, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidF128M( zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
+    goto uiZ96;
+ zero:
+    uiZ96 = packToF128UI96( signZ, 0, 0 );
+ uiZ96:
+    zWPtr[indexWordHi( 4 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_eq.c b/softfloat/source/f128M_eq.c
index 497fdbf..4f28f5f 100644
--- a/softfloat/source/f128M_eq.c
+++ b/softfloat/source/f128M_eq.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_eq( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t wordA, wordB, uiA96, uiB96;
-    bool possibleOppositeZeros;
-    uint32_t mashWord;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    wordA = aWPtr[indexWord( 4, 2 )];
-    wordB = bWPtr[indexWord( 4, 2 )];
-    if ( wordA != wordB ) goto false_checkSigNaNs;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    possibleOppositeZeros = false;
-    if ( uiA96 != uiB96 ) {
-        possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
-        if ( ! possibleOppositeZeros ) goto false_checkSigNaNs;
-    }
-    mashWord = wordA | wordB;
-    wordA = aWPtr[indexWord( 4, 1 )];
-    wordB = bWPtr[indexWord( 4, 1 )];
-    if ( wordA != wordB ) goto false_checkSigNaNs;
-    mashWord |= wordA | wordB;
-    wordA = aWPtr[indexWord( 4, 0 )];
-    wordB = bWPtr[indexWord( 4, 0 )];
-    if ( wordA != wordB ) goto false_checkSigNaNs;
-    if ( possibleOppositeZeros && ((mashWord | wordA | wordB) != 0) ) {
-        goto false_checkSigNaNs;
-    }
-    if ( ! softfloat_isNaNF128M( aWPtr ) && ! softfloat_isNaNF128M( bWPtr ) ) {
-        return true;
-    }
- false_checkSigNaNs:
-    if (
-           f128M_isSignalingNaN( (const float128_t *) aWPtr )
-        || f128M_isSignalingNaN( (const float128_t *) bWPtr )
-    ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-    }
-    return false;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_eq( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_eq( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t wordA, wordB, uiA96, uiB96;
+    bool possibleOppositeZeros;
+    uint32_t mashWord;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    wordA = aWPtr[indexWord( 4, 2 )];
+    wordB = bWPtr[indexWord( 4, 2 )];
+    if ( wordA != wordB ) goto false_checkSigNaNs;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    possibleOppositeZeros = false;
+    if ( uiA96 != uiB96 ) {
+        possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
+        if ( ! possibleOppositeZeros ) goto false_checkSigNaNs;
+    }
+    mashWord = wordA | wordB;
+    wordA = aWPtr[indexWord( 4, 1 )];
+    wordB = bWPtr[indexWord( 4, 1 )];
+    if ( wordA != wordB ) goto false_checkSigNaNs;
+    mashWord |= wordA | wordB;
+    wordA = aWPtr[indexWord( 4, 0 )];
+    wordB = bWPtr[indexWord( 4, 0 )];
+    if ( wordA != wordB ) goto false_checkSigNaNs;
+    if ( possibleOppositeZeros && ((mashWord | wordA | wordB) != 0) ) {
+        goto false_checkSigNaNs;
+    }
+    if ( ! softfloat_isNaNF128M( aWPtr ) && ! softfloat_isNaNF128M( bWPtr ) ) {
+        return true;
+    }
+ false_checkSigNaNs:
+    if (
+           f128M_isSignalingNaN( (const float128_t *) aWPtr )
+        || f128M_isSignalingNaN( (const float128_t *) bWPtr )
+    ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+    }
+    return false;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_eq_signaling.c b/softfloat/source/f128M_eq_signaling.c
index a9fa4d5..d2ea5f4 100644
--- a/softfloat/source/f128M_eq_signaling.c
+++ b/softfloat/source/f128M_eq_signaling.c
@@ -1,92 +1,92 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_eq_signaling( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t wordA, wordB, uiA96, uiB96;
-    bool possibleOppositeZeros;
-    uint32_t mashWord;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    wordA = aWPtr[indexWord( 4, 2 )];
-    wordB = bWPtr[indexWord( 4, 2 )];
-    if ( wordA != wordB ) return false;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    possibleOppositeZeros = false;
-    if ( uiA96 != uiB96 ) {
-        possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
-        if ( ! possibleOppositeZeros ) return false;
-    }
-    mashWord = wordA | wordB;
-    wordA = aWPtr[indexWord( 4, 1 )];
-    wordB = bWPtr[indexWord( 4, 1 )];
-    if ( wordA != wordB ) return false;
-    mashWord |= wordA | wordB;
-    wordA = aWPtr[indexWord( 4, 0 )];
-    wordB = bWPtr[indexWord( 4, 0 )];
-    return
-        (wordA == wordB)
-            && (! possibleOppositeZeros || ((mashWord | wordA | wordB) == 0));
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_eq_signaling( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_eq_signaling( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t wordA, wordB, uiA96, uiB96;
+    bool possibleOppositeZeros;
+    uint32_t mashWord;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    wordA = aWPtr[indexWord( 4, 2 )];
+    wordB = bWPtr[indexWord( 4, 2 )];
+    if ( wordA != wordB ) return false;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    possibleOppositeZeros = false;
+    if ( uiA96 != uiB96 ) {
+        possibleOppositeZeros = (((uiA96 | uiB96) & 0x7FFFFFFF) == 0);
+        if ( ! possibleOppositeZeros ) return false;
+    }
+    mashWord = wordA | wordB;
+    wordA = aWPtr[indexWord( 4, 1 )];
+    wordB = bWPtr[indexWord( 4, 1 )];
+    if ( wordA != wordB ) return false;
+    mashWord |= wordA | wordB;
+    wordA = aWPtr[indexWord( 4, 0 )];
+    wordB = bWPtr[indexWord( 4, 0 )];
+    return
+        (wordA == wordB)
+            && (! possibleOppositeZeros || ((mashWord | wordA | wordB) == 0));
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_le.c b/softfloat/source/f128M_le.c
index 7306e45..af1dcba 100644
--- a/softfloat/source/f128M_le.c
+++ b/softfloat/source/f128M_le.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_le( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t uiA96, uiB96;
-    bool signA, signB;
-    uint32_t wordA, wordB;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    signB = signF128UI96( uiB96 );
-    if ( signA != signB ) {
-        if ( signA ) return true;
-        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
-        wordA = aWPtr[indexWord( 4, 2 )];
-        wordB = bWPtr[indexWord( 4, 2 )];
-        if ( wordA | wordB ) return false;
-        wordA = aWPtr[indexWord( 4, 1 )];
-        wordB = bWPtr[indexWord( 4, 1 )];
-        if ( wordA | wordB ) return false;
-        wordA = aWPtr[indexWord( 4, 0 )];
-        wordB = bWPtr[indexWord( 4, 0 )];
-        return ((wordA | wordB) == 0);
-    }
-    if ( signA ) {
-        aWPtr = (const uint32_t *) bPtr;
-        bWPtr = (const uint32_t *) aPtr;
-    }
-    return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_le( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_le( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t uiA96, uiB96;
+    bool signA, signB;
+    uint32_t wordA, wordB;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 );
+    if ( signA != signB ) {
+        if ( signA ) return true;
+        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
+        wordA = aWPtr[indexWord( 4, 2 )];
+        wordB = bWPtr[indexWord( 4, 2 )];
+        if ( wordA | wordB ) return false;
+        wordA = aWPtr[indexWord( 4, 1 )];
+        wordB = bWPtr[indexWord( 4, 1 )];
+        if ( wordA | wordB ) return false;
+        wordA = aWPtr[indexWord( 4, 0 )];
+        wordB = bWPtr[indexWord( 4, 0 )];
+        return ((wordA | wordB) == 0);
+    }
+    if ( signA ) {
+        aWPtr = (const uint32_t *) bPtr;
+        bWPtr = (const uint32_t *) aPtr;
+    }
+    return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_le_quiet.c b/softfloat/source/f128M_le_quiet.c
index d9e4429..0d051b6 100644
--- a/softfloat/source/f128M_le_quiet.c
+++ b/softfloat/source/f128M_le_quiet.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_le_quiet( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t uiA96, uiB96;
-    bool signA, signB;
-    uint32_t wordA, wordB;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    signB = signF128UI96( uiB96 );
-    if ( signA != signB ) {
-        if ( signA ) return true;
-        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
-        wordA = aWPtr[indexWord( 4, 2 )];
-        wordB = bWPtr[indexWord( 4, 2 )];
-        if ( wordA | wordB ) return false;
-        wordA = aWPtr[indexWord( 4, 1 )];
-        wordB = bWPtr[indexWord( 4, 1 )];
-        if ( wordA | wordB ) return false;
-        wordA = aWPtr[indexWord( 4, 0 )];
-        wordB = bWPtr[indexWord( 4, 0 )];
-        return ((wordA | wordB) == 0);
-    }
-    if ( signA ) {
-        aWPtr = (const uint32_t *) bPtr;
-        bWPtr = (const uint32_t *) aPtr;
-    }
-    return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_le_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_le_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t uiA96, uiB96;
+    bool signA, signB;
+    uint32_t wordA, wordB;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 );
+    if ( signA != signB ) {
+        if ( signA ) return true;
+        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return false;
+        wordA = aWPtr[indexWord( 4, 2 )];
+        wordB = bWPtr[indexWord( 4, 2 )];
+        if ( wordA | wordB ) return false;
+        wordA = aWPtr[indexWord( 4, 1 )];
+        wordB = bWPtr[indexWord( 4, 1 )];
+        if ( wordA | wordB ) return false;
+        wordA = aWPtr[indexWord( 4, 0 )];
+        wordB = bWPtr[indexWord( 4, 0 )];
+        return ((wordA | wordB) == 0);
+    }
+    if ( signA ) {
+        aWPtr = (const uint32_t *) bPtr;
+        bWPtr = (const uint32_t *) aPtr;
+    }
+    return (softfloat_compare128M( aWPtr, bWPtr ) <= 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_lt.c b/softfloat/source/f128M_lt.c
index d2f797f..64ff9b4 100644
--- a/softfloat/source/f128M_lt.c
+++ b/softfloat/source/f128M_lt.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_lt( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t uiA96, uiB96;
-    bool signA, signB;
-    uint32_t wordA, wordB;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    signB = signF128UI96( uiB96 );
-    if ( signA != signB ) {
-        if ( signB ) return false;
-        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
-        wordA = aWPtr[indexWord( 4, 2 )];
-        wordB = bWPtr[indexWord( 4, 2 )];
-        if ( wordA | wordB ) return true;
-        wordA = aWPtr[indexWord( 4, 1 )];
-        wordB = bWPtr[indexWord( 4, 1 )];
-        if ( wordA | wordB ) return true;
-        wordA = aWPtr[indexWord( 4, 0 )];
-        wordB = bWPtr[indexWord( 4, 0 )];
-        return ((wordA | wordB) != 0);
-    }
-    if ( signA ) {
-        aWPtr = (const uint32_t *) bPtr;
-        bWPtr = (const uint32_t *) aPtr;
-    }
-    return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_lt( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_lt( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t uiA96, uiB96;
+    bool signA, signB;
+    uint32_t wordA, wordB;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 );
+    if ( signA != signB ) {
+        if ( signB ) return false;
+        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
+        wordA = aWPtr[indexWord( 4, 2 )];
+        wordB = bWPtr[indexWord( 4, 2 )];
+        if ( wordA | wordB ) return true;
+        wordA = aWPtr[indexWord( 4, 1 )];
+        wordB = bWPtr[indexWord( 4, 1 )];
+        if ( wordA | wordB ) return true;
+        wordA = aWPtr[indexWord( 4, 0 )];
+        wordB = bWPtr[indexWord( 4, 0 )];
+        return ((wordA | wordB) != 0);
+    }
+    if ( signA ) {
+        aWPtr = (const uint32_t *) bPtr;
+        bWPtr = (const uint32_t *) aPtr;
+    }
+    return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_lt_quiet.c b/softfloat/source/f128M_lt_quiet.c
index adbddea..6ccf3c8 100644
--- a/softfloat/source/f128M_lt_quiet.c
+++ b/softfloat/source/f128M_lt_quiet.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
-{
-
-    return f128_lt_quiet( *aPtr, *bPtr );
-
-}
-
-#else
-
-bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t uiA96, uiB96;
-    bool signA, signB;
-    uint32_t wordA, wordB;
-
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    signB = signF128UI96( uiB96 );
-    if ( signA != signB ) {
-        if ( signB ) return false;
-        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
-        wordA = aWPtr[indexWord( 4, 2 )];
-        wordB = bWPtr[indexWord( 4, 2 )];
-        if ( wordA | wordB ) return true;
-        wordA = aWPtr[indexWord( 4, 1 )];
-        wordB = bWPtr[indexWord( 4, 1 )];
-        if ( wordA | wordB ) return true;
-        wordA = aWPtr[indexWord( 4, 0 )];
-        wordB = bWPtr[indexWord( 4, 0 )];
-        return ((wordA | wordB) != 0);
-    }
-    if ( signA ) {
-        aWPtr = (const uint32_t *) bPtr;
-        bWPtr = (const uint32_t *) aPtr;
-    }
-    return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+
+    return f128_lt_quiet( *aPtr, *bPtr );
+
+}
+
+#else
+
+bool f128M_lt_quiet( const float128_t *aPtr, const float128_t *bPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t uiA96, uiB96;
+    bool signA, signB;
+    uint32_t wordA, wordB;
+
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        if ( f128M_isSignalingNaN( aPtr ) || f128M_isSignalingNaN( bPtr ) ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 );
+    if ( signA != signB ) {
+        if ( signB ) return false;
+        if ( (uiA96 | uiB96) & 0x7FFFFFFF ) return true;
+        wordA = aWPtr[indexWord( 4, 2 )];
+        wordB = bWPtr[indexWord( 4, 2 )];
+        if ( wordA | wordB ) return true;
+        wordA = aWPtr[indexWord( 4, 1 )];
+        wordB = bWPtr[indexWord( 4, 1 )];
+        if ( wordA | wordB ) return true;
+        wordA = aWPtr[indexWord( 4, 0 )];
+        wordB = bWPtr[indexWord( 4, 0 )];
+        return ((wordA | wordB) != 0);
+    }
+    if ( signA ) {
+        aWPtr = (const uint32_t *) bPtr;
+        bWPtr = (const uint32_t *) aPtr;
+    }
+    return (softfloat_compare128M( aWPtr, bWPtr ) < 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_mul.c b/softfloat/source/f128M_mul.c
index 4b8292a..f2d6051 100644
--- a/softfloat/source/f128M_mul.c
+++ b/softfloat/source/f128M_mul.c
@@ -1,158 +1,158 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-
-    *zPtr = f128_mul( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t *zWPtr;
-    uint32_t uiA96;
-    int32_t expA;
-    uint32_t uiB96;
-    int32_t expB;
-    bool signZ;
-    const uint32_t *ptr;
-    uint32_t uiZ96, sigA[4];
-    uint_fast8_t shiftDist;
-    uint32_t sigB[4];
-    int32_t expZ;
-    uint32_t sigProd[8], *extSigZPtr;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    expA = expF128UI96( uiA96 );
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    expB = expF128UI96( uiB96 );
-    signZ = signF128UI96( uiA96 ) ^ signF128UI96( uiB96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
-        ptr = aWPtr;
-        if ( ! expA ) goto possiblyInvalid;
-        if ( ! expB ) {
-            ptr = bWPtr;
-     possiblyInvalid:
-            if (
-                ! fracF128UI96( ptr[indexWordHi( 4 )] )
-                    && ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
-                              | ptr[indexWord( 4, 0 )])
-            ) {
-                softfloat_invalidF128M( zWPtr );
-                return;
-            }
-        }
-        uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
-        goto uiZ96;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA ) {
-        sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000;
-        sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-        sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-        sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-    } else {
-        expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
-        if ( expA == -128 ) goto zero;
-    }
-    if ( expB ) {
-        sigB[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000;
-        sigB[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )];
-        sigB[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )];
-        sigB[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )];
-    } else {
-        expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigB );
-        if ( expB == -128 ) goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x4000;
-    softfloat_mul128MTo256M( sigA, sigB, sigProd );
-    if (
-        sigProd[indexWord( 8, 2 )]
-            || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
-    ) {
-        sigProd[indexWord( 8, 3 )] |= 1;
-    }
-    extSigZPtr = &sigProd[indexMultiwordHi( 8, 5 )];
-    shiftDist = 16;
-    if ( extSigZPtr[indexWordHi( 5 )] & 2 ) {
-        ++expZ;
-        shiftDist = 15;
-    }
-    softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
-    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ96 = packToF128UI96( signZ, 0, 0 );
- uiZ96:
-    zWPtr[indexWordHi( 4 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+    *zPtr = f128_mul( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_mul( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t *zWPtr;
+    uint32_t uiA96;
+    int32_t expA;
+    uint32_t uiB96;
+    int32_t expB;
+    bool signZ;
+    const uint32_t *ptr;
+    uint32_t uiZ96, sigA[4];
+    uint_fast8_t shiftDist;
+    uint32_t sigB[4];
+    int32_t expZ;
+    uint32_t sigProd[8], *extSigZPtr;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    expA = expF128UI96( uiA96 );
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    expB = expF128UI96( uiB96 );
+    signZ = signF128UI96( uiA96 ) ^ signF128UI96( uiB96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        ptr = aWPtr;
+        if ( ! expA ) goto possiblyInvalid;
+        if ( ! expB ) {
+            ptr = bWPtr;
+     possiblyInvalid:
+            if (
+                ! fracF128UI96( ptr[indexWordHi( 4 )] )
+                    && ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
+                              | ptr[indexWord( 4, 0 )])
+            ) {
+                softfloat_invalidF128M( zWPtr );
+                return;
+            }
+        }
+        uiZ96 = packToF128UI96( signZ, 0x7FFF, 0 );
+        goto uiZ96;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA ) {
+        sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000;
+        sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+        sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+        sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+    } else {
+        expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
+        if ( expA == -128 ) goto zero;
+    }
+    if ( expB ) {
+        sigB[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000;
+        sigB[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )];
+        sigB[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )];
+        sigB[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )];
+    } else {
+        expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigB );
+        if ( expB == -128 ) goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x4000;
+    softfloat_mul128MTo256M( sigA, sigB, sigProd );
+    if (
+        sigProd[indexWord( 8, 2 )]
+            || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
+    ) {
+        sigProd[indexWord( 8, 3 )] |= 1;
+    }
+    extSigZPtr = &sigProd[indexMultiwordHi( 8, 5 )];
+    shiftDist = 16;
+    if ( extSigZPtr[indexWordHi( 5 )] & 2 ) {
+        ++expZ;
+        shiftDist = 15;
+    }
+    softfloat_shortShiftLeft160M( extSigZPtr, shiftDist, extSigZPtr );
+    softfloat_roundPackMToF128M( signZ, expZ, extSigZPtr, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ96 = packToF128UI96( signZ, 0, 0 );
+ uiZ96:
+    zWPtr[indexWordHi( 4 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_mulAdd.c b/softfloat/source/f128M_mulAdd.c
index 2b0b7fe..e2f95df 100644
--- a/softfloat/source/f128M_mulAdd.c
+++ b/softfloat/source/f128M_mulAdd.c
@@ -1,92 +1,92 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_mulAdd(
-     const float128_t *aPtr,
-     const float128_t *bPtr,
-     const float128_t *cPtr,
-     float128_t *zPtr
- )
-{
-    const uint64_t *aWPtr, *bWPtr, *cWPtr;
-    uint_fast64_t uiA64, uiA0;
-    uint_fast64_t uiB64, uiB0;
-    uint_fast64_t uiC64, uiC0;
-
-    aWPtr = (const uint64_t *) aPtr;
-    bWPtr = (const uint64_t *) bPtr;
-    cWPtr = (const uint64_t *) cPtr;
-    uiA64 = aWPtr[indexWord( 2, 1 )];
-    uiA0  = aWPtr[indexWord( 2, 0 )];
-    uiB64 = bWPtr[indexWord( 2, 1 )];
-    uiB0  = bWPtr[indexWord( 2, 0 )];
-    uiC64 = cWPtr[indexWord( 2, 1 )];
-    uiC0  = cWPtr[indexWord( 2, 0 )];
-    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
-
-}
-
-#else
-
-void
- f128M_mulAdd(
-     const float128_t *aPtr,
-     const float128_t *bPtr,
-     const float128_t *cPtr,
-     float128_t *zPtr
- )
-{
-
-    softfloat_mulAddF128M(
-        (const uint32_t *) aPtr,
-        (const uint32_t *) bPtr,
-        (const uint32_t *) cPtr,
-        (uint32_t *) zPtr,
-        0
-    );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_mulAdd(
+     const float128_t *aPtr,
+     const float128_t *bPtr,
+     const float128_t *cPtr,
+     float128_t *zPtr
+ )
+{
+    const uint64_t *aWPtr, *bWPtr, *cWPtr;
+    uint_fast64_t uiA64, uiA0;
+    uint_fast64_t uiB64, uiB0;
+    uint_fast64_t uiC64, uiC0;
+
+    aWPtr = (const uint64_t *) aPtr;
+    bWPtr = (const uint64_t *) bPtr;
+    cWPtr = (const uint64_t *) cPtr;
+    uiA64 = aWPtr[indexWord( 2, 1 )];
+    uiA0  = aWPtr[indexWord( 2, 0 )];
+    uiB64 = bWPtr[indexWord( 2, 1 )];
+    uiB0  = bWPtr[indexWord( 2, 0 )];
+    uiC64 = cWPtr[indexWord( 2, 1 )];
+    uiC0  = cWPtr[indexWord( 2, 0 )];
+    *zPtr = softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+
+}
+
+#else
+
+void
+ f128M_mulAdd(
+     const float128_t *aPtr,
+     const float128_t *bPtr,
+     const float128_t *cPtr,
+     float128_t *zPtr
+ )
+{
+
+    softfloat_mulAddF128M(
+        (const uint32_t *) aPtr,
+        (const uint32_t *) bPtr,
+        (const uint32_t *) cPtr,
+        (uint32_t *) zPtr,
+        0
+    );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_rem.c b/softfloat/source/f128M_rem.c
index 39aafdd..645ec99 100644
--- a/softfloat/source/f128M_rem.c
+++ b/softfloat/source/f128M_rem.c
@@ -1,182 +1,182 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-
-    *zPtr = f128_rem( *aPtr, *bPtr );
-
-}
-
-#else
-
-void
- f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-    const uint32_t *aWPtr, *bWPtr;
-    uint32_t *zWPtr, uiA96;
-    int32_t expA, expB;
-    uint32_t x[4], rem1[5], *remPtr;
-    bool signRem;
-    int32_t expDiff;
-    uint32_t q, recip32;
-    uint64_t q64;
-    uint32_t rem2[5], *altRemPtr, *newRemPtr, wordMeanRem;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    bWPtr = (const uint32_t *) bPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    expA = expF128UI96( uiA96 );
-    expB = expF128UI96( bWPtr[indexWordHi( 4 )] );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
-        if ( expA == 0x7FFF ) goto invalid;
-        goto copyA;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA < expB - 1 ) goto copyA;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expB = softfloat_shiftNormSigF128M( bWPtr, 13, x );
-    if ( expB == -128 ) goto invalid;
-    remPtr = &rem1[indexMultiwordLo( 5, 4 )];
-    expA = softfloat_shiftNormSigF128M( aWPtr, 13, remPtr );
-    if ( expA == -128 ) goto copyA;
-    signRem = signF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( expDiff < 1 ) {
-        if ( expDiff < -1 ) goto copyA;
-        if ( expDiff ) {
-            --expB;
-            softfloat_add128M( x, x, x );
-            q = 0;
-        } else {
-            q = (softfloat_compare128M( x, remPtr ) <= 0);
-            if ( q ) softfloat_sub128M( remPtr, x, remPtr );
-        }
-    } else {
-        recip32 =
-            softfloat_approxRecip32_1(
-                ((uint64_t) x[indexWord( 4, 3 )]<<32 | x[indexWord( 4, 2 )])
-                    >>30
-            );
-        expDiff -= 30;
-        for (;;) {
-            q64 = (uint64_t) remPtr[indexWordHi( 4 )] * recip32;
-            if ( expDiff < 0 ) break;
-            q = (q64 + 0x80000000)>>32;
-            softfloat_remStep128MBy32( remPtr, 29, x, q, remPtr );
-            if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
-                softfloat_add128M( remPtr, x, remPtr );
-            }
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -29 here.)
-        *--------------------------------------------------------------------*/
-        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
-        softfloat_remStep128MBy32( remPtr, expDiff + 30, x, q, remPtr );
-        if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
-            altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
-            softfloat_add128M( remPtr, x, altRemPtr );
-            goto selectRem;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
-    do {
-        ++q;
-        newRemPtr = altRemPtr;
-        softfloat_sub128M( remPtr, x, newRemPtr );
-        altRemPtr = remPtr;
-        remPtr = newRemPtr;
-    } while ( ! (remPtr[indexWordHi( 4 )] & 0x80000000) );
- selectRem:
-    softfloat_add128M( remPtr, altRemPtr, x );
-    wordMeanRem = x[indexWordHi( 4 )];
-    if (
-        (wordMeanRem & 0x80000000)
-            || (! wordMeanRem && (q & 1) && ! x[indexWord( 4, 0 )]
-                    && ! (x[indexWord( 4, 2 )] | x[indexWord( 4, 1 )]))
-    ) {
-        remPtr = altRemPtr;
-    }
-    if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
-        signRem = ! signRem;
-        softfloat_negX128M( remPtr );
-    }
-    remPtr -= indexMultiwordLo( 5, 4 );
-    remPtr[indexWordHi( 5 )] = 0;
-    softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidF128M( zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- copyA:
-    zWPtr[indexWordHi( 4 )] = uiA96;
-    zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+    *zPtr = f128_rem( *aPtr, *bPtr );
+
+}
+
+#else
+
+void
+ f128M_rem( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+    const uint32_t *aWPtr, *bWPtr;
+    uint32_t *zWPtr, uiA96;
+    int32_t expA, expB;
+    uint32_t x[4], rem1[5], *remPtr;
+    bool signRem;
+    int32_t expDiff;
+    uint32_t q, recip32;
+    uint64_t q64;
+    uint32_t rem2[5], *altRemPtr, *newRemPtr, wordMeanRem;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    bWPtr = (const uint32_t *) bPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    expA = expF128UI96( uiA96 );
+    expB = expF128UI96( bWPtr[indexWordHi( 4 )] );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        if ( expA == 0x7FFF ) goto invalid;
+        goto copyA;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA < expB - 1 ) goto copyA;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expB = softfloat_shiftNormSigF128M( bWPtr, 13, x );
+    if ( expB == -128 ) goto invalid;
+    remPtr = &rem1[indexMultiwordLo( 5, 4 )];
+    expA = softfloat_shiftNormSigF128M( aWPtr, 13, remPtr );
+    if ( expA == -128 ) goto copyA;
+    signRem = signF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( expDiff < 1 ) {
+        if ( expDiff < -1 ) goto copyA;
+        if ( expDiff ) {
+            --expB;
+            softfloat_add128M( x, x, x );
+            q = 0;
+        } else {
+            q = (softfloat_compare128M( x, remPtr ) <= 0);
+            if ( q ) softfloat_sub128M( remPtr, x, remPtr );
+        }
+    } else {
+        recip32 =
+            softfloat_approxRecip32_1(
+                ((uint64_t) x[indexWord( 4, 3 )]<<32 | x[indexWord( 4, 2 )])
+                    >>30
+            );
+        expDiff -= 30;
+        for (;;) {
+            q64 = (uint64_t) remPtr[indexWordHi( 4 )] * recip32;
+            if ( expDiff < 0 ) break;
+            q = (q64 + 0x80000000)>>32;
+            softfloat_remStep128MBy32( remPtr, 29, x, q, remPtr );
+            if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+                softfloat_add128M( remPtr, x, remPtr );
+            }
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -29 here.)
+        *--------------------------------------------------------------------*/
+        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+        softfloat_remStep128MBy32( remPtr, expDiff + 30, x, q, remPtr );
+        if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+            altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
+            softfloat_add128M( remPtr, x, altRemPtr );
+            goto selectRem;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    altRemPtr = &rem2[indexMultiwordLo( 5, 4 )];
+    do {
+        ++q;
+        newRemPtr = altRemPtr;
+        softfloat_sub128M( remPtr, x, newRemPtr );
+        altRemPtr = remPtr;
+        remPtr = newRemPtr;
+    } while ( ! (remPtr[indexWordHi( 4 )] & 0x80000000) );
+ selectRem:
+    softfloat_add128M( remPtr, altRemPtr, x );
+    wordMeanRem = x[indexWordHi( 4 )];
+    if (
+        (wordMeanRem & 0x80000000)
+            || (! wordMeanRem && (q & 1) && ! x[indexWord( 4, 0 )]
+                    && ! (x[indexWord( 4, 2 )] | x[indexWord( 4, 1 )]))
+    ) {
+        remPtr = altRemPtr;
+    }
+    if ( remPtr[indexWordHi( 4 )] & 0x80000000 ) {
+        signRem = ! signRem;
+        softfloat_negX128M( remPtr );
+    }
+    remPtr -= indexMultiwordLo( 5, 4 );
+    remPtr[indexWordHi( 5 )] = 0;
+    softfloat_normRoundPackMToF128M( signRem, expB + 18, remPtr, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidF128M( zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ copyA:
+    zWPtr[indexWordHi( 4 )] = uiA96;
+    zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_roundToInt.c b/softfloat/source/f128M_roundToInt.c
index b96d742..c467126 100644
--- a/softfloat/source/f128M_roundToInt.c
+++ b/softfloat/source/f128M_roundToInt.c
@@ -1,223 +1,223 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_roundToInt(
-     const float128_t *aPtr,
-     uint_fast8_t roundingMode,
-     bool exact,
-     float128_t *zPtr
- )
-{
-
-    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-void
- f128M_roundToInt(
-     const float128_t *aPtr,
-     uint_fast8_t roundingMode,
-     bool exact,
-     float128_t *zPtr
- )
-{
-    const uint32_t *aWPtr;
-    uint32_t *zWPtr;
-    uint32_t ui96;
-    int32_t exp;
-    uint32_t sigExtra;
-    bool sign;
-    uint_fast8_t bitPos;
-    bool roundNear;
-    unsigned int index, lastIndex;
-    bool extra;
-    uint32_t wordA, bit, wordZ;
-    uint_fast8_t carry;
-    uint32_t extrasMask;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    ui96 = aWPtr[indexWordHi( 4 )];
-    exp = expF128UI96( ui96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp < 0x3FFF ) {
-        zWPtr[indexWord( 4, 2 )] = 0;
-        zWPtr[indexWord( 4, 1 )] = 0;
-        zWPtr[indexWord( 4, 0 )] = 0;
-        sigExtra = aWPtr[indexWord( 4, 2 )];
-        if ( !sigExtra ) {
-            sigExtra = aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )];
-        }
-        if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        sign = signF128UI96( ui96 );
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !fracF128UI96( ui96 ) && !sigExtra ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0x3FFE ) goto mag1;
-            break;
-         case softfloat_round_min:
-            if ( sign ) goto mag1;
-            break;
-         case softfloat_round_max:
-            if ( !sign ) goto mag1;
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            goto mag1;
-#endif
-        }
-        ui96 = packToF128UI96( sign, 0, 0 );
-        goto ui96;
-     mag1:
-        ui96 = packToF128UI96( sign, 0x3FFF, 0 );
-        goto ui96;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x406F <= exp ) {
-        if (
-            (exp == 0x7FFF)
-                && (fracF128UI96( ui96 )
-                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                                | aWPtr[indexWord( 4, 0 )]))
-        ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
-            return;
-        }
-        zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-        zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-        zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-        goto ui96;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    bitPos = 0x406F - exp;
-    roundNear =
-           (roundingMode == softfloat_round_near_maxMag)
-        || (roundingMode == softfloat_round_near_even);
-    bitPos -= roundNear;
-    index = indexWordLo( 4 );
-    lastIndex = indexWordHi( 4 );
-    extra = 0;
-    for (;;) {
-        wordA = aWPtr[index];
-        if ( bitPos < 32 ) break;
-        if ( wordA ) extra = 1;
-        zWPtr[index] = 0;
-        index += wordIncr;
-        bitPos -= 32;
-    }
-    bit = (uint32_t) 1<<bitPos;
-    if ( roundNear ) {
-        wordZ = wordA + bit;
-        carry = (wordZ < wordA);
-        bit <<= 1;
-        extrasMask = bit - 1;
-        if ( exact && (extra || (wordA & extrasMask)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        if (
-            (roundingMode == softfloat_round_near_even)
-                && !extra && !(wordZ & extrasMask)
-        ) {
-            if ( !bit ) {
-                zWPtr[index] = wordZ;
-                index += wordIncr;
-                wordZ = aWPtr[index] + carry;
-                carry &= !wordZ;
-                zWPtr[index] = wordZ & ~1;
-                goto propagateCarry;
-            }
-            wordZ &= ~bit;
-        }
-    } else {
-        wordZ = wordA;
-        carry = 0;
-        extrasMask = bit - 1;
-        if ( extra || (wordA & extrasMask) ) {
-            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-            if (
-                roundingMode
-                    == (signF128UI96( ui96 ) ? softfloat_round_min
-                            : softfloat_round_max)
-            ) {
-                wordZ += bit;
-                carry = (wordZ < wordA);
-#ifdef SOFTFLOAT_ROUND_ODD
-            } else if ( roundingMode == softfloat_round_odd ) {
-                wordZ |= bit;
-#endif
-            }
-        }
-    }
-    wordZ &= ~extrasMask;
-    zWPtr[index] = wordZ;
- propagateCarry:
-    while ( index != lastIndex ) {
-        index += wordIncr;
-        wordZ = aWPtr[index] + carry;
-        zWPtr[index] = wordZ;
-        carry &= !wordZ;
-    }
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- ui96:
-    zWPtr[indexWordHi( 4 )] = ui96;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_roundToInt(
+     const float128_t *aPtr,
+     uint_fast8_t roundingMode,
+     bool exact,
+     float128_t *zPtr
+ )
+{
+
+    *zPtr = f128_roundToInt( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+void
+ f128M_roundToInt(
+     const float128_t *aPtr,
+     uint_fast8_t roundingMode,
+     bool exact,
+     float128_t *zPtr
+ )
+{
+    const uint32_t *aWPtr;
+    uint32_t *zWPtr;
+    uint32_t ui96;
+    int32_t exp;
+    uint32_t sigExtra;
+    bool sign;
+    uint_fast8_t bitPos;
+    bool roundNear;
+    unsigned int index, lastIndex;
+    bool extra;
+    uint32_t wordA, bit, wordZ;
+    uint_fast8_t carry;
+    uint32_t extrasMask;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    ui96 = aWPtr[indexWordHi( 4 )];
+    exp = expF128UI96( ui96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp < 0x3FFF ) {
+        zWPtr[indexWord( 4, 2 )] = 0;
+        zWPtr[indexWord( 4, 1 )] = 0;
+        zWPtr[indexWord( 4, 0 )] = 0;
+        sigExtra = aWPtr[indexWord( 4, 2 )];
+        if ( !sigExtra ) {
+            sigExtra = aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )];
+        }
+        if ( !sigExtra && !(ui96 & 0x7FFFFFFF) ) goto ui96;
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        sign = signF128UI96( ui96 );
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !fracF128UI96( ui96 ) && !sigExtra ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0x3FFE ) goto mag1;
+            break;
+         case softfloat_round_min:
+            if ( sign ) goto mag1;
+            break;
+         case softfloat_round_max:
+            if ( !sign ) goto mag1;
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            goto mag1;
+#endif
+        }
+        ui96 = packToF128UI96( sign, 0, 0 );
+        goto ui96;
+     mag1:
+        ui96 = packToF128UI96( sign, 0x3FFF, 0 );
+        goto ui96;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x406F <= exp ) {
+        if (
+            (exp == 0x7FFF)
+                && (fracF128UI96( ui96 )
+                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                                | aWPtr[indexWord( 4, 0 )]))
+        ) {
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            return;
+        }
+        zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+        zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+        zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+        goto ui96;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    bitPos = 0x406F - exp;
+    roundNear =
+           (roundingMode == softfloat_round_near_maxMag)
+        || (roundingMode == softfloat_round_near_even);
+    bitPos -= roundNear;
+    index = indexWordLo( 4 );
+    lastIndex = indexWordHi( 4 );
+    extra = 0;
+    for (;;) {
+        wordA = aWPtr[index];
+        if ( bitPos < 32 ) break;
+        if ( wordA ) extra = 1;
+        zWPtr[index] = 0;
+        index += wordIncr;
+        bitPos -= 32;
+    }
+    bit = (uint32_t) 1<<bitPos;
+    if ( roundNear ) {
+        wordZ = wordA + bit;
+        carry = (wordZ < wordA);
+        bit <<= 1;
+        extrasMask = bit - 1;
+        if ( exact && (extra || (wordA & extrasMask)) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        if (
+            (roundingMode == softfloat_round_near_even)
+                && !extra && !(wordZ & extrasMask)
+        ) {
+            if ( !bit ) {
+                zWPtr[index] = wordZ;
+                index += wordIncr;
+                wordZ = aWPtr[index] + carry;
+                carry &= !wordZ;
+                zWPtr[index] = wordZ & ~1;
+                goto propagateCarry;
+            }
+            wordZ &= ~bit;
+        }
+    } else {
+        wordZ = wordA;
+        carry = 0;
+        extrasMask = bit - 1;
+        if ( extra || (wordA & extrasMask) ) {
+            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+            if (
+                roundingMode
+                    == (signF128UI96( ui96 ) ? softfloat_round_min
+                            : softfloat_round_max)
+            ) {
+                wordZ += bit;
+                carry = (wordZ < wordA);
+#ifdef SOFTFLOAT_ROUND_ODD
+            } else if ( roundingMode == softfloat_round_odd ) {
+                wordZ |= bit;
+#endif
+            }
+        }
+    }
+    wordZ &= ~extrasMask;
+    zWPtr[index] = wordZ;
+ propagateCarry:
+    while ( index != lastIndex ) {
+        index += wordIncr;
+        wordZ = aWPtr[index] + carry;
+        zWPtr[index] = wordZ;
+        carry &= !wordZ;
+    }
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ ui96:
+    zWPtr[indexWordHi( 4 )] = ui96;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_sqrt.c b/softfloat/source/f128M_sqrt.c
index a984208..1ede5ef 100644
--- a/softfloat/source/f128M_sqrt.c
+++ b/softfloat/source/f128M_sqrt.c
@@ -1,228 +1,228 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
-{
-
-    *zPtr = f128_sqrt( *aPtr );
-
-}
-
-#else
-
-void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t *zWPtr;
-    uint32_t uiA96;
-    bool signA;
-    int32_t rawExpA;
-    uint32_t rem[6];
-    int32_t expA, expZ;
-    uint64_t rem64;
-    uint32_t sig32A, recipSqrt32, sig32Z, qs[3], q;
-    uint64_t sig64Z;
-    uint32_t term[5];
-    uint64_t x64;
-    uint32_t y[5], rem32;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    signA = signF128UI96( uiA96 );
-    rawExpA  = expF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( rawExpA == 0x7FFF ) {
-        if (
-            fracF128UI96( uiA96 )
-                || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                        | aWPtr[indexWord( 4, 0 )])
-        ) {
-            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
-            return;
-        }
-        if ( ! signA ) goto copyA;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = softfloat_shiftNormSigF128M( aWPtr, 13 - (rawExpA & 1), rem );
-    if ( expA == -128 ) goto copyA;
-    if ( signA ) goto invalid;
-    /*------------------------------------------------------------------------
-    | (`sig32Z' is guaranteed to be a lower bound on the square root of
-    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
-    | `sigA'.)
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
-    expA &= 1;
-    rem64 = (uint64_t) rem[indexWord( 4, 3 )]<<32 | rem[indexWord( 4, 2 )];
-    if ( expA ) {
-        if ( ! rawExpA ) {
-            softfloat_shortShiftRight128M( rem, 1, rem );
-            rem64 >>= 1;
-        }
-        sig32A = rem64>>29;
-    } else {
-        sig32A = rem64>>30;
-    }
-    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
-    sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
-    if ( expA ) sig32Z >>= 1;
-    qs[2] = sig32Z;
-    rem64 -= (uint64_t) sig32Z * sig32Z;
-    rem[indexWord( 4, 3 )] = rem64>>32;
-    rem[indexWord( 4, 2 )] = rem64;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
-    sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
-    term[indexWord( 4, 3 )] = 0;
-    term[indexWord( 4, 0 )] = 0;
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        x64 = ((uint64_t) sig32Z<<32) + sig64Z;
-        term[indexWord( 4, 2 )] = x64>>32;
-        term[indexWord( 4, 1 )] = x64;
-        softfloat_remStep128MBy32( rem, 29, term, q, y );
-        rem32 = y[indexWord( 4, 3 )];
-        if ( ! (rem32 & 0x80000000) ) break;
-        --q;
-        sig64Z -= 1<<3;
-    }
-    qs[1] = q;
-    rem64 = (uint64_t) rem32<<32 | y[indexWord( 4, 2 )];
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
-    if ( rem64>>34 ) q += recipSqrt32;
-    sig64Z <<= 1;
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        x64 = sig64Z + (q>>26);
-        term[indexWord( 4, 2 )] = x64>>32;
-        term[indexWord( 4, 1 )] = x64;
-        term[indexWord( 4, 0 )] = q<<6;
-        softfloat_remStep128MBy32(
-            y, 29, term, q, &rem[indexMultiwordHi( 6, 4 )] );
-        rem32 = rem[indexWordHi( 6 )];
-        if ( ! (rem32 & 0x80000000) ) break;
-        --q;
-    }
-    qs[0] = q;
-    rem64 = (uint64_t) rem32<<32 | rem[indexWord( 6, 4 )];
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
-    if ( rem64>>34 ) q += recipSqrt32;
-    x64 = (uint64_t) q<<27;
-    y[indexWord( 5, 0 )] = x64;
-    x64 = ((uint64_t) qs[0]<<24) + (x64>>32);
-    y[indexWord( 5, 1 )] = x64;
-    x64 = ((uint64_t) qs[1]<<21) + (x64>>32);
-    y[indexWord( 5, 2 )] = x64;
-    x64 = ((uint64_t) qs[2]<<18) + (x64>>32);
-    y[indexWord( 5, 3 )] = x64;
-    y[indexWord( 5, 4 )] = x64>>32;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (q & 0xF) <= 2 ) {
-        q &= ~3;
-        y[indexWordLo( 5 )] = q<<27;
-        term[indexWord( 5, 4 )] = 0;
-        term[indexWord( 5, 3 )] = 0;
-        term[indexWord( 5, 2 )] = 0;
-        term[indexWord( 5, 1 )] = q>>6;
-        term[indexWord( 5, 0 )] = q<<26;
-        softfloat_sub160M( y, term, term );
-        rem[indexWord( 6, 1 )] = 0;
-        rem[indexWord( 6, 0 )] = 0;
-        softfloat_remStep160MBy32(
-            &rem[indexMultiwordLo( 6, 5 )],
-            14,
-            term,
-            q,
-            &rem[indexMultiwordLo( 6, 5 )]
-        );
-        rem32 = rem[indexWord( 6, 4 )];
-        if ( rem32 & 0x80000000 ) {
-            softfloat_sub1X160M( y );
-        } else {
-            if (
-                rem32 || rem[indexWord( 6, 0 )] || rem[indexWord( 6, 1 )]
-                    || (rem[indexWord( 6, 3 )] | rem[indexWord( 6, 2 )])
-            ) {
-                y[indexWordLo( 5 )] |= 1;
-            }
-        }
-    }
-    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidF128M( zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- copyA:
-    zWPtr[indexWordHi( 4 )] = uiA96;
-    zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+{
+
+    *zPtr = f128_sqrt( *aPtr );
+
+}
+
+#else
+
+void f128M_sqrt( const float128_t *aPtr, float128_t *zPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t *zWPtr;
+    uint32_t uiA96;
+    bool signA;
+    int32_t rawExpA;
+    uint32_t rem[6];
+    int32_t expA, expZ;
+    uint64_t rem64;
+    uint32_t sig32A, recipSqrt32, sig32Z, qs[3], q;
+    uint64_t sig64Z;
+    uint32_t term[5];
+    uint64_t x64;
+    uint32_t y[5], rem32;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    signA = signF128UI96( uiA96 );
+    rawExpA  = expF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( rawExpA == 0x7FFF ) {
+        if (
+            fracF128UI96( uiA96 )
+                || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                        | aWPtr[indexWord( 4, 0 )])
+        ) {
+            softfloat_propagateNaNF128M( aWPtr, 0, zWPtr );
+            return;
+        }
+        if ( ! signA ) goto copyA;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = softfloat_shiftNormSigF128M( aWPtr, 13 - (rawExpA & 1), rem );
+    if ( expA == -128 ) goto copyA;
+    if ( signA ) goto invalid;
+    /*------------------------------------------------------------------------
+    | (`sig32Z' is guaranteed to be a lower bound on the square root of
+    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+    | `sigA'.)
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
+    expA &= 1;
+    rem64 = (uint64_t) rem[indexWord( 4, 3 )]<<32 | rem[indexWord( 4, 2 )];
+    if ( expA ) {
+        if ( ! rawExpA ) {
+            softfloat_shortShiftRight128M( rem, 1, rem );
+            rem64 >>= 1;
+        }
+        sig32A = rem64>>29;
+    } else {
+        sig32A = rem64>>30;
+    }
+    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+    sig32Z = ((uint64_t) sig32A * recipSqrt32)>>32;
+    if ( expA ) sig32Z >>= 1;
+    qs[2] = sig32Z;
+    rem64 -= (uint64_t) sig32Z * sig32Z;
+    rem[indexWord( 4, 3 )] = rem64>>32;
+    rem[indexWord( 4, 2 )] = rem64;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+    sig64Z = ((uint64_t) sig32Z<<32) + ((uint64_t) q<<3);
+    term[indexWord( 4, 3 )] = 0;
+    term[indexWord( 4, 0 )] = 0;
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        x64 = ((uint64_t) sig32Z<<32) + sig64Z;
+        term[indexWord( 4, 2 )] = x64>>32;
+        term[indexWord( 4, 1 )] = x64;
+        softfloat_remStep128MBy32( rem, 29, term, q, y );
+        rem32 = y[indexWord( 4, 3 )];
+        if ( ! (rem32 & 0x80000000) ) break;
+        --q;
+        sig64Z -= 1<<3;
+    }
+    qs[1] = q;
+    rem64 = (uint64_t) rem32<<32 | y[indexWord( 4, 2 )];
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32;
+    if ( rem64>>34 ) q += recipSqrt32;
+    sig64Z <<= 1;
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        x64 = sig64Z + (q>>26);
+        term[indexWord( 4, 2 )] = x64>>32;
+        term[indexWord( 4, 1 )] = x64;
+        term[indexWord( 4, 0 )] = q<<6;
+        softfloat_remStep128MBy32(
+            y, 29, term, q, &rem[indexMultiwordHi( 6, 4 )] );
+        rem32 = rem[indexWordHi( 6 )];
+        if ( ! (rem32 & 0x80000000) ) break;
+        --q;
+    }
+    qs[0] = q;
+    rem64 = (uint64_t) rem32<<32 | rem[indexWord( 6, 4 )];
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = (((uint32_t) (rem64>>2) * (uint64_t) recipSqrt32)>>32) + 2;
+    if ( rem64>>34 ) q += recipSqrt32;
+    x64 = (uint64_t) q<<27;
+    y[indexWord( 5, 0 )] = x64;
+    x64 = ((uint64_t) qs[0]<<24) + (x64>>32);
+    y[indexWord( 5, 1 )] = x64;
+    x64 = ((uint64_t) qs[1]<<21) + (x64>>32);
+    y[indexWord( 5, 2 )] = x64;
+    x64 = ((uint64_t) qs[2]<<18) + (x64>>32);
+    y[indexWord( 5, 3 )] = x64;
+    y[indexWord( 5, 4 )] = x64>>32;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (q & 0xF) <= 2 ) {
+        q &= ~3;
+        y[indexWordLo( 5 )] = q<<27;
+        term[indexWord( 5, 4 )] = 0;
+        term[indexWord( 5, 3 )] = 0;
+        term[indexWord( 5, 2 )] = 0;
+        term[indexWord( 5, 1 )] = q>>6;
+        term[indexWord( 5, 0 )] = q<<26;
+        softfloat_sub160M( y, term, term );
+        rem[indexWord( 6, 1 )] = 0;
+        rem[indexWord( 6, 0 )] = 0;
+        softfloat_remStep160MBy32(
+            &rem[indexMultiwordLo( 6, 5 )],
+            14,
+            term,
+            q,
+            &rem[indexMultiwordLo( 6, 5 )]
+        );
+        rem32 = rem[indexWord( 6, 4 )];
+        if ( rem32 & 0x80000000 ) {
+            softfloat_sub1X160M( y );
+        } else {
+            if (
+                rem32 || rem[indexWord( 6, 0 )] || rem[indexWord( 6, 1 )]
+                    || (rem[indexWord( 6, 3 )] | rem[indexWord( 6, 2 )])
+            ) {
+                y[indexWordLo( 5 )] |= 1;
+            }
+        }
+    }
+    softfloat_roundPackMToF128M( 0, expZ, y, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidF128M( zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ copyA:
+    zWPtr[indexWordHi( 4 )] = uiA96;
+    zWPtr[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_sub.c b/softfloat/source/f128M_sub.c
index 5d65c79..1b609fd 100644
--- a/softfloat/source/f128M_sub.c
+++ b/softfloat/source/f128M_sub.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-    const uint64_t *aWPtr, *bWPtr;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float128_t
-        (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    aWPtr = (const uint64_t *) aPtr;
-    bWPtr = (const uint64_t *) bPtr;
-    uiA64 = aWPtr[indexWord( 2, 1 )];
-    uiA0  = aWPtr[indexWord( 2, 0 )];
-    signA = signF128UI64( uiA64 );
-    uiB64 = bWPtr[indexWord( 2, 1 )];
-    uiB0  = bWPtr[indexWord( 2, 0 )];
-    signB = signF128UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
-#else
-
-void
- f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
-{
-
-    softfloat_addF128M(
-        (const uint32_t *) aPtr,
-        (const uint32_t *) bPtr,
-        (uint32_t *) zPtr,
-        true
-    );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+    const uint64_t *aWPtr, *bWPtr;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float128_t
+        (*magsFuncPtr)(
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    aWPtr = (const uint64_t *) aPtr;
+    bWPtr = (const uint64_t *) bPtr;
+    uiA64 = aWPtr[indexWord( 2, 1 )];
+    uiA0  = aWPtr[indexWord( 2, 0 )];
+    signA = signF128UI64( uiA64 );
+    uiB64 = bWPtr[indexWord( 2, 1 )];
+    uiB0  = bWPtr[indexWord( 2, 0 )];
+    signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        *zPtr = softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        *zPtr = softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
+    *zPtr = (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
+#else
+
+void
+ f128M_sub( const float128_t *aPtr, const float128_t *bPtr, float128_t *zPtr )
+{
+
+    softfloat_addF128M(
+        (const uint32_t *) aPtr,
+        (const uint32_t *) bPtr,
+        (uint32_t *) zPtr,
+        true
+    );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_extF80M.c b/softfloat/source/f128M_to_extF80M.c
index b0340c7..fe8b0fc 100644
--- a/softfloat/source/f128M_to_extF80M.c
+++ b/softfloat/source/f128M_to_extF80M.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
-{
-
-    *zPtr = f128_to_extF80( *aPtr );
-
-}
-
-#else
-
-void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
-{
-    const uint32_t *aWPtr;
-    struct extFloat80M *zSPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    struct commonNaN commonNaN;
-    uint32_t sig[4];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    zSPtr = (struct extFloat80M *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( softfloat_isNaNF128M( aWPtr ) ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
-            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
-            return;
-        }
-        zSPtr->signExp = packToExtF80UI64( sign, 0x7FFF );
-        zSPtr->signif = UINT64_C( 0x8000000000000000 );
-        return;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp = softfloat_shiftNormSigF128M( aWPtr, 15, sig );
-    if ( exp == -128 ) {
-        zSPtr->signExp = packToExtF80UI64( sign, 0 );
-        zSPtr->signif = 0;
-        return;
-    }
-    if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
-    softfloat_roundPackMToExtF80M(
-        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+{
+
+    *zPtr = f128_to_extF80( *aPtr );
+
+}
+
+#else
+
+void f128M_to_extF80M( const float128_t *aPtr, extFloat80_t *zPtr )
+{
+    const uint32_t *aWPtr;
+    struct extFloat80M *zSPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    struct commonNaN commonNaN;
+    uint32_t sig[4];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    zSPtr = (struct extFloat80M *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( softfloat_isNaNF128M( aWPtr ) ) {
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
+            return;
+        }
+        zSPtr->signExp = packToExtF80UI64( sign, 0x7FFF );
+        zSPtr->signif = UINT64_C( 0x8000000000000000 );
+        return;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp = softfloat_shiftNormSigF128M( aWPtr, 15, sig );
+    if ( exp == -128 ) {
+        zSPtr->signExp = packToExtF80UI64( sign, 0 );
+        zSPtr->signif = 0;
+        return;
+    }
+    if ( sig[indexWord( 4, 0 )] ) sig[indexWord( 4, 1 )] |= 1;
+    softfloat_roundPackMToExtF80M(
+        sign, exp, &sig[indexMultiwordHi( 4, 3 )], 80, zSPtr );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_f16.c b/softfloat/source/f128M_to_f16.c
index 95109a7..4f0c5bb 100644
--- a/softfloat/source/f128M_to_f16.c
+++ b/softfloat/source/f128M_to_f16.c
@@ -1,113 +1,113 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float16_t f128M_to_f16( const float128_t *aPtr )
-{
-
-    return f128_to_f16( *aPtr );
-
-}
-
-#else
-
-float16_t f128M_to_f16( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint32_t frac32;
-    struct commonNaN commonNaN;
-    uint16_t uiZ, frac16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    frac32 =
-        fracF128UI96( uiA96 )
-            | ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                    | aWPtr[indexWord( 4, 0 )])
-                   != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac32 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac16 = frac32>>2 | (frac32 & 3);
-    if ( ! (exp | frac16) ) {
-        uiZ = packToF16UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3FF1;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x40 ) exp = -0x40;
-    }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float16_t f128M_to_f16( const float128_t *aPtr )
+{
+
+    return f128_to_f16( *aPtr );
+
+}
+
+#else
+
+float16_t f128M_to_f16( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint32_t frac32;
+    struct commonNaN commonNaN;
+    uint16_t uiZ, frac16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    frac32 =
+        fracF128UI96( uiA96 )
+            | ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                    | aWPtr[indexWord( 4, 0 )])
+                   != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac32 ) {
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac16 = frac32>>2 | (frac32 & 3);
+    if ( ! (exp | frac16) ) {
+        uiZ = packToF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3FF1;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x40 ) exp = -0x40;
+    }
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_f32.c b/softfloat/source/f128M_to_f32.c
index 4542deb..8b73de0 100644
--- a/softfloat/source/f128M_to_f32.c
+++ b/softfloat/source/f128M_to_f32.c
@@ -1,109 +1,109 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float32_t f128M_to_f32( const float128_t *aPtr )
-{
-
-    return f128_to_f32( *aPtr );
-
-}
-
-#else
-
-float32_t f128M_to_f32( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint64_t frac64;
-    struct commonNaN commonNaN;
-    uint32_t uiZ, frac32;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    frac64 =
-        (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]
-            | ((aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )]) != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
-    if ( ! (exp | frac32) ) {
-        uiZ = packToF32UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3F81;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float32_t f128M_to_f32( const float128_t *aPtr )
+{
+
+    return f128_to_f32( *aPtr );
+
+}
+
+#else
+
+float32_t f128M_to_f32( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint64_t frac64;
+    struct commonNaN commonNaN;
+    uint32_t uiZ, frac32;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    frac64 =
+        (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )]
+            | ((aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )]) != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 ) {
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
+    if ( ! (exp | frac32) ) {
+        uiZ = packToF32UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3F81;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_f64.c b/softfloat/source/f128M_to_f64.c
index 6213bb7..1cddd34 100644
--- a/softfloat/source/f128M_to_f64.c
+++ b/softfloat/source/f128M_to_f64.c
@@ -1,112 +1,112 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float64_t f128M_to_f64( const float128_t *aPtr )
-{
-
-    return f128_to_f64( *aPtr );
-
-}
-
-#else
-
-float64_t f128M_to_f64( const float128_t *aPtr )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint64_t frac64;
-    struct commonNaN commonNaN;
-    uint64_t uiZ;
-    uint32_t frac32;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    frac64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
-            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac32 = aWPtr[indexWord( 4, 1 )];
-    frac64 = frac64<<14 | frac32>>18;
-    if ( (frac32 & 0x0003FFFF) || aWPtr[indexWord( 4, 0 )] ) frac64 |= 1;
-    if ( ! (exp | frac64) ) {
-        uiZ = packToF64UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3C01;
-    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return
-        softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float64_t f128M_to_f64( const float128_t *aPtr )
+{
+
+    return f128_to_f64( *aPtr );
+
+}
+
+#else
+
+float64_t f128M_to_f64( const float128_t *aPtr )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint64_t frac64;
+    struct commonNaN commonNaN;
+    uint64_t uiZ;
+    uint32_t frac32;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    frac64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 || aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) {
+            softfloat_f128MToCommonNaN( aWPtr, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac32 = aWPtr[indexWord( 4, 1 )];
+    frac64 = frac64<<14 | frac32>>18;
+    if ( (frac32 & 0x0003FFFF) || aWPtr[indexWord( 4, 0 )] ) frac64 |= 1;
+    if ( ! (exp | frac64) ) {
+        uiZ = packToF64UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3C01;
+    if ( sizeof (int_fast16_t) < sizeof (int32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return
+        softfloat_roundPackToF64(
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_i32.c b/softfloat/source/f128M_to_i32.c
index 54cc6f6..1265c60 100644
--- a/softfloat/source/f128M_to_i32.c
+++ b/softfloat/source/f128M_to_i32.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return f128_to_i32( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-int_fast32_t
- f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint64_t sig64;
-    int32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
-    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && sig64 ) {
-#if (i32_fromNaN == i32_fromPosOverflow)
-        sign = 0;
-#elif (i32_fromNaN == i32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return i32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-    shiftDist = 0x4023 - exp;
-    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return f128_to_i32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast32_t
+ f128M_to_i32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint64_t sig64;
+    int32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && sig64 ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+        sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return i32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+    shiftDist = 0x4023 - exp;
+    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_i32_r_minMag.c b/softfloat/source/f128M_to_i32_r_minMag.c
index 1f22039..dde3dea 100644
--- a/softfloat/source/f128M_to_i32_r_minMag.c
+++ b/softfloat/source/f128M_to_i32_r_minMag.c
@@ -1,106 +1,106 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
-{
-
-    return f128_to_i32_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint64_t sig64;
-    int32_t shiftDist;
-    uint32_t absZ, uiZ;
-    union { uint32_t ui; int32_t i; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
-    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp < 0x3FFF ) {
-        if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x401F <= exp ) goto invalid;
-    shiftDist = 0x402F - exp;
-    sig64 |= UINT64_C( 0x0001000000000000 );
-    absZ = sig64>>shiftDist;
-    uiZ = sign ? -absZ : absZ;
-    if ( uiZ>>31 != sign ) goto invalid;
-    if ( exact && ((uint64_t) absZ<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    uZ.ui = uiZ;
-    return uZ.i;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && sig64 ? i32_fromNaN
-            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+{
+
+    return f128_to_i32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *aPtr, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint64_t sig64;
+    int32_t shiftDist;
+    uint32_t absZ, uiZ;
+    union { uint32_t ui; int32_t i; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp < 0x3FFF ) {
+        if ( exact && (exp | sig64) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x401F <= exp ) goto invalid;
+    shiftDist = 0x402F - exp;
+    sig64 |= UINT64_C( 0x0001000000000000 );
+    absZ = sig64>>shiftDist;
+    uiZ = sign ? -absZ : absZ;
+    if ( uiZ>>31 != sign ) goto invalid;
+    if ( exact && ((uint64_t) absZ<<shiftDist != sig64) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    uZ.ui = uiZ;
+    return uZ.i;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && sig64 ? i32_fromNaN
+            : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_i64.c b/softfloat/source/f128M_to_i64.c
index 08844b6..c30673f 100644
--- a/softfloat/source/f128M_to_i64.c
+++ b/softfloat/source/f128M_to_i64.c
@@ -1,102 +1,102 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return f128_to_i64( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-int_fast64_t
- f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint32_t sig96;
-    int32_t shiftDist;
-    uint32_t sig[4];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign  = signF128UI96( uiA96 );
-    exp   = expF128UI96( uiA96 );
-    sig96 = fracF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x404F - exp;
-    if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF)
-                && (sig96
-                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                                | aWPtr[indexWord( 4, 0 )]))
-                ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig96 |= 0x00010000;
-    sig[indexWord( 4, 3 )] = sig96;
-    sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-    sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-    sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-    softfloat_shiftRightJam128M( sig, shiftDist, sig );
-    return
-        softfloat_roundMToI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return f128_to_i64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+int_fast64_t
+ f128M_to_i64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint32_t sig96;
+    int32_t shiftDist;
+    uint32_t sig[4];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign  = signF128UI96( uiA96 );
+    exp   = expF128UI96( uiA96 );
+    sig96 = fracF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x404F - exp;
+    if ( shiftDist < 17 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF)
+                && (sig96
+                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                                | aWPtr[indexWord( 4, 0 )]))
+                ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig96 |= 0x00010000;
+    sig[indexWord( 4, 3 )] = sig96;
+    sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+    sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+    sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+    softfloat_shiftRightJam128M( sig, shiftDist, sig );
+    return
+        softfloat_roundMToI64(
+            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_i64_r_minMag.c b/softfloat/source/f128M_to_i64_r_minMag.c
index da3d28a..bcc7950 100644
--- a/softfloat/source/f128M_to_i64_r_minMag.c
+++ b/softfloat/source/f128M_to_i64_r_minMag.c
@@ -1,124 +1,124 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
-{
-
-    return f128_to_i64_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint32_t sig96;
-    int32_t shiftDist;
-    uint32_t sig[4];
-    uint64_t uiZ;
-    union { uint64_t ui; int64_t i; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign  = signF128UI96( uiA96 );
-    exp   = expF128UI96( uiA96 );
-    sig96 = fracF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist < 0 ) goto invalid;
-    if ( exact ) {
-        if ( exp ) sig96 |= 0x00010000;
-        sig[indexWord( 4, 3 )] = sig96;
-        sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-        sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-        sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-        softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
-        uiZ = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )];
-        if ( uiZ>>63 && (! sign || (uiZ != UINT64_C( 0x8000000000000000 ))) ) {
-            goto invalid;
-        }
-        if ( sig[indexWordLo( 4 )] ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    } else {
-        if ( 64 <= shiftDist ) return 0;
-        uiZ =
-              (uint64_t) sig96<<47
-            | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15
-            | aWPtr[indexWord( 4, 1 )]>>17;
-        if ( shiftDist ) {
-            uiZ |= UINT64_C( 0x8000000000000000 );
-            uiZ >>= shiftDist;
-        } else {
-            if ( uiZ || ! sign ) goto invalid;
-            uiZ |= UINT64_C( 0x8000000000000000 );
-        }
-    }
-    if ( sign ) uiZ = -uiZ;
-    uZ.ui = uiZ;
-    return uZ.i;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF)
-            && (sig96
-                    || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                            | aWPtr[indexWord( 4, 0 )]))
-            ? i64_fromNaN
-            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+{
+
+    return f128_to_i64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *aPtr, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint32_t sig96;
+    int32_t shiftDist;
+    uint32_t sig[4];
+    uint64_t uiZ;
+    union { uint64_t ui; int64_t i; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign  = signF128UI96( uiA96 );
+    exp   = expF128UI96( uiA96 );
+    sig96 = fracF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist < 0 ) goto invalid;
+    if ( exact ) {
+        if ( exp ) sig96 |= 0x00010000;
+        sig[indexWord( 4, 3 )] = sig96;
+        sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+        sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+        sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+        softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
+        uiZ = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )];
+        if ( uiZ>>63 && (! sign || (uiZ != UINT64_C( 0x8000000000000000 ))) ) {
+            goto invalid;
+        }
+        if ( sig[indexWordLo( 4 )] ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    } else {
+        if ( 64 <= shiftDist ) return 0;
+        uiZ =
+              (uint64_t) sig96<<47
+            | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15
+            | aWPtr[indexWord( 4, 1 )]>>17;
+        if ( shiftDist ) {
+            uiZ |= UINT64_C( 0x8000000000000000 );
+            uiZ >>= shiftDist;
+        } else {
+            if ( uiZ || ! sign ) goto invalid;
+            uiZ |= UINT64_C( 0x8000000000000000 );
+        }
+    }
+    if ( sign ) uiZ = -uiZ;
+    uZ.ui = uiZ;
+    return uZ.i;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF)
+            && (sig96
+                    || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                            | aWPtr[indexWord( 4, 0 )]))
+            ? i64_fromNaN
+            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_ui32.c b/softfloat/source/f128M_to_ui32.c
index c1baa06..33ed93a 100644
--- a/softfloat/source/f128M_to_ui32.c
+++ b/softfloat/source/f128M_to_ui32.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return f128_to_ui32( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-uint_fast32_t
- f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint64_t sig64;
-    int32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign = signF128UI96( uiA96 );
-    exp  = expF128UI96( uiA96 );
-    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
-    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && sig64 ) {
-#if (ui32_fromNaN == ui32_fromPosOverflow)
-        sign = 0;
-#elif (ui32_fromNaN == ui32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return ui32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-    shiftDist = 0x4023 - exp;
-    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return f128_to_ui32( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast32_t
+ f128M_to_ui32( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint64_t sig64;
+    int32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign = signF128UI96( uiA96 );
+    exp  = expF128UI96( uiA96 );
+    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && sig64 ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+        sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return ui32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+    shiftDist = 0x4023 - exp;
+    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_ui32_r_minMag.c b/softfloat/source/f128M_to_ui32_r_minMag.c
index a1aca62..87813c0 100644
--- a/softfloat/source/f128M_to_ui32_r_minMag.c
+++ b/softfloat/source/f128M_to_ui32_r_minMag.c
@@ -1,102 +1,102 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
-{
-
-    return f128_to_ui32_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    int32_t exp;
-    uint64_t sig64;
-    int32_t shiftDist;
-    bool sign;
-    uint32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    exp = expF128UI96( uiA96 );
-    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
-    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( 49 <= shiftDist ) {
-        if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF128UI96( uiA96 );
-    if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && sig64 ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig64 |= UINT64_C( 0x0001000000000000 );
-    z = sig64>>shiftDist;
-    if ( exact && ((uint64_t) z<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+{
+
+    return f128_to_ui32_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *aPtr, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    int32_t exp;
+    uint64_t sig64;
+    int32_t shiftDist;
+    bool sign;
+    uint32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    exp = expF128UI96( uiA96 );
+    sig64 = (uint64_t) fracF128UI96( uiA96 )<<32 | aWPtr[indexWord( 4, 2 )];
+    if ( aWPtr[indexWord( 4, 1 )] | aWPtr[indexWord( 4, 0 )] ) sig64 |= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( 49 <= shiftDist ) {
+        if ( exact && (exp | sig64) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF128UI96( uiA96 );
+    if ( sign || (shiftDist < 17) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && sig64 ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig64 |= UINT64_C( 0x0001000000000000 );
+    z = sig64>>shiftDist;
+    if ( exact && ((uint64_t) z<<shiftDist != sig64) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_ui64.c b/softfloat/source/f128M_to_ui64.c
index abaa855..86c80d3 100644
--- a/softfloat/source/f128M_to_ui64.c
+++ b/softfloat/source/f128M_to_ui64.c
@@ -1,102 +1,102 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-
-    return f128_to_ui64( *aPtr, roundingMode, exact );
-
-}
-
-#else
-
-uint_fast64_t
- f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint32_t sig96;
-    int32_t shiftDist;
-    uint32_t sig[4];
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign  = signF128UI96( uiA96 );
-    exp   = expF128UI96( uiA96 );
-    sig96 = fracF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x404F - exp;
-    if ( shiftDist < 17 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF)
-                && (sig96
-                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                                | aWPtr[indexWord( 4, 0 )]))
-                ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig96 |= 0x00010000;
-    sig[indexWord( 4, 3 )] = sig96;
-    sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-    sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-    sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-    softfloat_shiftRightJam128M( sig, shiftDist, sig );
-    return
-        softfloat_roundMToUI64(
-            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+
+    return f128_to_ui64( *aPtr, roundingMode, exact );
+
+}
+
+#else
+
+uint_fast64_t
+ f128M_to_ui64( const float128_t *aPtr, uint_fast8_t roundingMode, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint32_t sig96;
+    int32_t shiftDist;
+    uint32_t sig[4];
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign  = signF128UI96( uiA96 );
+    exp   = expF128UI96( uiA96 );
+    sig96 = fracF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x404F - exp;
+    if ( shiftDist < 17 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF)
+                && (sig96
+                        || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                                | aWPtr[indexWord( 4, 0 )]))
+                ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig96 |= 0x00010000;
+    sig[indexWord( 4, 3 )] = sig96;
+    sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+    sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+    sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+    softfloat_shiftRightJam128M( sig, shiftDist, sig );
+    return
+        softfloat_roundMToUI64(
+            sign, sig + indexMultiwordLo( 4, 3 ), roundingMode, exact );
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128M_to_ui64_r_minMag.c b/softfloat/source/f128M_to_ui64_r_minMag.c
index 7a1b602..503a605 100644
--- a/softfloat/source/f128M_to_ui64_r_minMag.c
+++ b/softfloat/source/f128M_to_ui64_r_minMag.c
@@ -1,114 +1,114 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
-{
-
-    return f128_to_ui64_r_minMag( *aPtr, exact );
-
-}
-
-#else
-
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
-{
-    const uint32_t *aWPtr;
-    uint32_t uiA96;
-    bool sign;
-    int32_t exp;
-    uint32_t sig96;
-    int32_t shiftDist;
-    uint32_t sig[4];
-    uint64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    aWPtr = (const uint32_t *) aPtr;
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    sign  = signF128UI96( uiA96 );
-    exp   = expF128UI96( uiA96 );
-    sig96 = fracF128UI96( uiA96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x403E - exp;
-    if ( shiftDist < 0 ) goto invalid;
-    if ( exact ) {
-        if ( exp ) sig96 |= 0x00010000;
-        sig[indexWord( 4, 3 )] = sig96;
-        sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-        sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-        sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-        softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
-        z = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )];
-        if ( sign && z ) goto invalid;
-        if ( sig[indexWordLo( 4 )] ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    } else {
-        if ( 64 <= shiftDist ) return 0;
-        if ( sign ) goto invalid;
-        z =   UINT64_C( 0x8000000000000000 )
-            | (uint64_t) sig96<<47
-            | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15
-            | aWPtr[indexWord( 4, 1 )]>>17;
-        z >>= shiftDist;
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF)
-            && (sig96
-                    || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                            | aWPtr[indexWord( 4, 0 )]))
-            ? ui64_fromNaN
-            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+{
+
+    return f128_to_ui64_r_minMag( *aPtr, exact );
+
+}
+
+#else
+
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *aPtr, bool exact )
+{
+    const uint32_t *aWPtr;
+    uint32_t uiA96;
+    bool sign;
+    int32_t exp;
+    uint32_t sig96;
+    int32_t shiftDist;
+    uint32_t sig[4];
+    uint64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    aWPtr = (const uint32_t *) aPtr;
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    sign  = signF128UI96( uiA96 );
+    exp   = expF128UI96( uiA96 );
+    sig96 = fracF128UI96( uiA96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x403E - exp;
+    if ( shiftDist < 0 ) goto invalid;
+    if ( exact ) {
+        if ( exp ) sig96 |= 0x00010000;
+        sig[indexWord( 4, 3 )] = sig96;
+        sig[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+        sig[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+        sig[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+        softfloat_shiftRightJam128M( sig, shiftDist + 17, sig );
+        z = (uint64_t) sig[indexWord( 4, 2 )]<<32 | sig[indexWord( 4, 1 )];
+        if ( sign && z ) goto invalid;
+        if ( sig[indexWordLo( 4 )] ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    } else {
+        if ( 64 <= shiftDist ) return 0;
+        if ( sign ) goto invalid;
+        z =   UINT64_C( 0x8000000000000000 )
+            | (uint64_t) sig96<<47
+            | (uint64_t) aWPtr[indexWord( 4, 2 )]<<15
+            | aWPtr[indexWord( 4, 1 )]>>17;
+        z >>= shiftDist;
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF)
+            && (sig96
+                    || (aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                            | aWPtr[indexWord( 4, 0 )]))
+            ? ui64_fromNaN
+            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f128_add.c b/softfloat/source/f128_add.c
index e9caba6..2f6c6b5 100644
--- a/softfloat/source/f128_add.c
+++ b/softfloat/source/f128_add.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t f128_add( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float128_t
-        (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    signB = signF128UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t f128_add( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float128_t
+        (*magsFuncPtr)(
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_addMagsF128 : softfloat_subMagsF128;
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/f128_div.c b/softfloat/source/f128_div.c
index 0693db7..dcd3ecb 100644
--- a/softfloat/source/f128_div.c
+++ b/softfloat/source/f128_div.c
@@ -1,199 +1,199 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f128_div( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    int_fast32_t expA;
-    struct uint128 sigA;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-    int_fast32_t expB;
-    struct uint128 sigB;
-    bool signZ;
-    struct exp32_sig128 normExpSig;
-    int_fast32_t expZ;
-    struct uint128 rem;
-    uint_fast32_t recip32;
-    int ix;
-    uint_fast64_t q64;
-    uint_fast32_t q;
-    struct uint128 term;
-    uint_fast32_t qs[3];
-    uint_fast64_t sigZExtra;
-    struct uint128 sigZ, uiZ;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    expA  = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    signB = signF128UI64( uiB64 );
-    expB  = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
-        if ( expB == 0x7FFF ) {
-            if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! (sigB.v64 | sigB.v0) ) {
-            if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! (sigA.v64 | sigA.v0) ) goto zero;
-        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x3FFE;
-    sigA.v64 |= UINT64_C( 0x0001000000000000 );
-    sigB.v64 |= UINT64_C( 0x0001000000000000 );
-    rem = sigA;
-    if ( softfloat_lt128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 ) ) {
-        --expZ;
-        rem = softfloat_add128( sigA.v64, sigA.v0, sigA.v64, sigA.v0 );
-    }
-    recip32 = softfloat_approxRecip32_1( sigB.v64>>17 );
-    ix = 3;
-    for (;;) {
-        q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32;
-        q = (q64 + 0x80000000)>>32;
-        --ix;
-        if ( ix < 0 ) break;
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            --q;
-            rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-        }
-        qs[ix] = q;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ((q + 1) & 7) < 2 ) {
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            --q;
-            rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-        } else if ( softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 ) ) {
-            ++q;
-            rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-        }
-        if ( rem.v64 | rem.v0 ) q |= 1;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigZExtra = (uint64_t) ((uint_fast64_t) q<<60);
-    term = softfloat_shortShiftLeft128( 0, qs[1], 54 );
-    sigZ =
-        softfloat_add128(
-            (uint_fast64_t) qs[2]<<19, ((uint_fast64_t) qs[0]<<25) + (q>>4),
-            term.v64, term.v0
-        );
-    return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
-    goto uiZ0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ.v64 = packToF128UI64( signZ, 0, 0 );
- uiZ0:
-    uiZ.v0 = 0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f128_div( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    int_fast32_t expA;
+    struct uint128 sigA;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+    int_fast32_t expB;
+    struct uint128 sigB;
+    bool signZ;
+    struct exp32_sig128 normExpSig;
+    int_fast32_t expZ;
+    struct uint128 rem;
+    uint_fast32_t recip32;
+    int ix;
+    uint_fast64_t q64;
+    uint_fast32_t q;
+    struct uint128 term;
+    uint_fast32_t qs[3];
+    uint_fast64_t sigZExtra;
+    struct uint128 sigZ, uiZ;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    expA  = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    signB = signF128UI64( uiB64 );
+    expB  = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
+        if ( expB == 0x7FFF ) {
+            if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! (sigB.v64 | sigB.v0) ) {
+            if ( ! (expA | sigA.v64 | sigA.v0) ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! (sigA.v64 | sigA.v0) ) goto zero;
+        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x3FFE;
+    sigA.v64 |= UINT64_C( 0x0001000000000000 );
+    sigB.v64 |= UINT64_C( 0x0001000000000000 );
+    rem = sigA;
+    if ( softfloat_lt128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 ) ) {
+        --expZ;
+        rem = softfloat_add128( sigA.v64, sigA.v0, sigA.v64, sigA.v0 );
+    }
+    recip32 = softfloat_approxRecip32_1( sigB.v64>>17 );
+    ix = 3;
+    for (;;) {
+        q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32;
+        q = (q64 + 0x80000000)>>32;
+        --ix;
+        if ( ix < 0 ) break;
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            --q;
+            rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+        }
+        qs[ix] = q;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ((q + 1) & 7) < 2 ) {
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            --q;
+            rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+        } else if ( softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 ) ) {
+            ++q;
+            rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+        }
+        if ( rem.v64 | rem.v0 ) q |= 1;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigZExtra = (uint64_t) ((uint_fast64_t) q<<60);
+    term = softfloat_shortShiftLeft128( 0, qs[1], 54 );
+    sigZ =
+        softfloat_add128(
+            (uint_fast64_t) qs[2]<<19, ((uint_fast64_t) qs[0]<<25) + (q>>4),
+            term.v64, term.v0
+        );
+    return
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
+    goto uiZ0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ.v64 = packToF128UI64( signZ, 0, 0 );
+ uiZ0:
+    uiZ.v0 = 0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_eq.c b/softfloat/source/f128_eq.c
index 9462fc2..65183da 100644
--- a/softfloat/source/f128_eq.c
+++ b/softfloat/source/f128_eq.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f128_eq( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNF128UI( uiA64, uiA0 )
-            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return
-           (uiA0 == uiB0)
-        && (   (uiA64 == uiB64)
-            || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
-           );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f128_eq( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNF128UI( uiA64, uiA0 )
+            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    return
+           (uiA0 == uiB0)
+        && (   (uiA64 == uiB64)
+            || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+           );
+
+}
+
diff --git a/softfloat/source/f128_eq_signaling.c b/softfloat/source/f128_eq_signaling.c
index 5d0819d..892b7da 100644
--- a/softfloat/source/f128_eq_signaling.c
+++ b/softfloat/source/f128_eq_signaling.c
@@ -1,67 +1,67 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f128_eq_signaling( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return
-           (uiA0 == uiB0)
-        && (   (uiA64 == uiB64)
-            || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
-           );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f128_eq_signaling( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    return
+           (uiA0 == uiB0)
+        && (   (uiA64 == uiB64)
+            || (! uiA0 && ! ((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+           );
+
+}
+
diff --git a/softfloat/source/f128_isSignalingNaN.c b/softfloat/source/f128_isSignalingNaN.c
index a764ff6..f8e5d23 100644
--- a/softfloat/source/f128_isSignalingNaN.c
+++ b/softfloat/source/f128_isSignalingNaN.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f128_isSignalingNaN( float128_t a )
-{
-    union ui128_f128 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF128UI( uA.ui.v64, uA.ui.v0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f128_isSignalingNaN( float128_t a )
+{
+    union ui128_f128 uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNF128UI( uA.ui.v64, uA.ui.v0 );
+
+}
+
diff --git a/softfloat/source/f128_le.c b/softfloat/source/f128_le.c
index 521a1cb..28d452b 100644
--- a/softfloat/source/f128_le.c
+++ b/softfloat/source/f128_le.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f128_le( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF128UI64( uiA64 );
-    signB = signF128UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA
-                  || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                            | uiA0 | uiB0)
-            : ((uiA64 == uiB64) && (uiA0 == uiB0))
-                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f128_le( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF128UI64( uiA64 );
+    signB = signF128UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA
+                  || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                            | uiA0 | uiB0)
+            : ((uiA64 == uiB64) && (uiA0 == uiB0))
+                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/f128_le_quiet.c b/softfloat/source/f128_le_quiet.c
index 820b28b..f3ea5a6 100644
--- a/softfloat/source/f128_le_quiet.c
+++ b/softfloat/source/f128_le_quiet.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f128_le_quiet( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNF128UI( uiA64, uiA0 )
-            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF128UI64( uiA64 );
-    signB = signF128UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA
-                  || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                            | uiA0 | uiB0)
-            : ((uiA64 == uiB64) && (uiA0 == uiB0))
-                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f128_le_quiet( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNF128UI( uiA64, uiA0 )
+            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF128UI64( uiA64 );
+    signB = signF128UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA
+                  || ! (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                            | uiA0 | uiB0)
+            : ((uiA64 == uiB64) && (uiA0 == uiB0))
+                  || (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/f128_lt.c b/softfloat/source/f128_lt.c
index fa46ae2..97589a4 100644
--- a/softfloat/source/f128_lt.c
+++ b/softfloat/source/f128_lt.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f128_lt( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF128UI64( uiA64 );
-    signB = signF128UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA
-                  && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                          | uiA0 | uiB0)
-            : ((uiA64 != uiB64) || (uiA0 != uiB0))
-                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f128_lt( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF128UI64( uiA64 );
+    signB = signF128UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA
+                  && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                          | uiA0 | uiB0)
+            : ((uiA64 != uiB64) || (uiA0 != uiB0))
+                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/f128_lt_quiet.c b/softfloat/source/f128_lt_quiet.c
index d491de2..0daf329 100644
--- a/softfloat/source/f128_lt_quiet.c
+++ b/softfloat/source/f128_lt_quiet.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f128_lt_quiet( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
-        if (
-               softfloat_isSigNaNF128UI( uiA64, uiA0 )
-            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF128UI64( uiA64 );
-    signB = signF128UI64( uiB64 );
-    return
-        (signA != signB)
-            ? signA
-                  && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                          | uiA0 | uiB0)
-            : ((uiA64 != uiB64) || (uiA0 != uiB0))
-                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f128_lt_quiet( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    if ( isNaNF128UI( uiA64, uiA0 ) || isNaNF128UI( uiB64, uiB0 ) ) {
+        if (
+               softfloat_isSigNaNF128UI( uiA64, uiA0 )
+            || softfloat_isSigNaNF128UI( uiB64, uiB0 )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF128UI64( uiA64 );
+    signB = signF128UI64( uiB64 );
+    return
+        (signA != signB)
+            ? signA
+                  && (((uiA64 | uiB64) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                          | uiA0 | uiB0)
+            : ((uiA64 != uiB64) || (uiA0 != uiB0))
+                  && (signA ^ softfloat_lt128( uiA64, uiA0, uiB64, uiB0 ));
+
+}
+
diff --git a/softfloat/source/f128_mul.c b/softfloat/source/f128_mul.c
index 24af86a..7dff6ed 100644
--- a/softfloat/source/f128_mul.c
+++ b/softfloat/source/f128_mul.c
@@ -1,163 +1,163 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f128_mul( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    int_fast32_t expA;
-    struct uint128 sigA;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-    int_fast32_t expB;
-    struct uint128 sigB;
-    bool signZ;
-    uint_fast64_t magBits;
-    struct exp32_sig128 normExpSig;
-    int_fast32_t expZ;
-    uint64_t sig256Z[4];
-    uint_fast64_t sigZExtra;
-    struct uint128 sigZ;
-    struct uint128_extra sig128Extra;
-    struct uint128 uiZ;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    expA  = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    signB = signF128UI64( uiB64 );
-    expB  = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if (
-            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
-        ) {
-            goto propagateNaN;
-        }
-        magBits = expB | sigB.v64 | sigB.v0;
-        goto infArg;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-        magBits = expA | sigA.v64 | sigA.v0;
-        goto infArg;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! (sigA.v64 | sigA.v0) ) goto zero;
-        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! (sigB.v64 | sigB.v0) ) goto zero;
-        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x4000;
-    sigA.v64 |= UINT64_C( 0x0001000000000000 );
-    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 16 );
-    softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z );
-    sigZExtra = sig256Z[indexWord( 4, 1 )] | (sig256Z[indexWord( 4, 0 )] != 0);
-    sigZ =
-        softfloat_add128(
-            sig256Z[indexWord( 4, 3 )], sig256Z[indexWord( 4, 2 )],
-            sigA.v64, sigA.v0
-        );
-    if ( UINT64_C( 0x0002000000000000 ) <= sigZ.v64 ) {
-        ++expZ;
-        sig128Extra =
-            softfloat_shortShiftRightJam128Extra(
-                sigZ.v64, sigZ.v0, sigZExtra, 1 );
-        sigZ = sig128Extra.v;
-        sigZExtra = sig128Extra.extra;
-    }
-    return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infArg:
-    if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ.v64 = defaultNaNF128UI64;
-        uiZ.v0  = defaultNaNF128UI0;
-        goto uiZ;
-    }
-    uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
-    goto uiZ0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ.v64 = packToF128UI64( signZ, 0, 0 );
- uiZ0:
-    uiZ.v0 = 0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f128_mul( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    int_fast32_t expA;
+    struct uint128 sigA;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+    int_fast32_t expB;
+    struct uint128 sigB;
+    bool signZ;
+    uint_fast64_t magBits;
+    struct exp32_sig128 normExpSig;
+    int_fast32_t expZ;
+    uint64_t sig256Z[4];
+    uint_fast64_t sigZExtra;
+    struct uint128 sigZ;
+    struct uint128_extra sig128Extra;
+    struct uint128 uiZ;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    expA  = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    signB = signF128UI64( uiB64 );
+    expB  = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if (
+            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
+        ) {
+            goto propagateNaN;
+        }
+        magBits = expB | sigB.v64 | sigB.v0;
+        goto infArg;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+        magBits = expA | sigA.v64 | sigA.v0;
+        goto infArg;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! (sigA.v64 | sigA.v0) ) goto zero;
+        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! (sigB.v64 | sigB.v0) ) goto zero;
+        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x4000;
+    sigA.v64 |= UINT64_C( 0x0001000000000000 );
+    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 16 );
+    softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z );
+    sigZExtra = sig256Z[indexWord( 4, 1 )] | (sig256Z[indexWord( 4, 0 )] != 0);
+    sigZ =
+        softfloat_add128(
+            sig256Z[indexWord( 4, 3 )], sig256Z[indexWord( 4, 2 )],
+            sigA.v64, sigA.v0
+        );
+    if ( UINT64_C( 0x0002000000000000 ) <= sigZ.v64 ) {
+        ++expZ;
+        sig128Extra =
+            softfloat_shortShiftRightJam128Extra(
+                sigZ.v64, sigZ.v0, sigZExtra, 1 );
+        sigZ = sig128Extra.v;
+        sigZExtra = sig128Extra.extra;
+    }
+    return
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infArg:
+    if ( ! magBits ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ.v64 = defaultNaNF128UI64;
+        uiZ.v0  = defaultNaNF128UI0;
+        goto uiZ;
+    }
+    uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
+    goto uiZ0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ.v64 = packToF128UI64( signZ, 0, 0 );
+ uiZ0:
+    uiZ.v0 = 0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_mulAdd.c b/softfloat/source/f128_mulAdd.c
index c7272d4..8d4850e 100644
--- a/softfloat/source/f128_mulAdd.c
+++ b/softfloat/source/f128_mulAdd.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    union ui128_f128 uC;
-    uint_fast64_t uiC64, uiC0;
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    uC.f = c;
-    uiC64 = uC.ui.v64;
-    uiC0  = uC.ui.v0;
-    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t f128_mulAdd( float128_t a, float128_t b, float128_t c )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    union ui128_f128 uC;
+    uint_fast64_t uiC64, uiC0;
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    uC.f = c;
+    uiC64 = uC.ui.v64;
+    uiC0  = uC.ui.v0;
+    return softfloat_mulAddF128( uiA64, uiA0, uiB64, uiB0, uiC64, uiC0, 0 );
+
+}
+
diff --git a/softfloat/source/f128_rem.c b/softfloat/source/f128_rem.c
index f525f69..28d3df6 100644
--- a/softfloat/source/f128_rem.c
+++ b/softfloat/source/f128_rem.c
@@ -1,190 +1,190 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f128_rem( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    int_fast32_t expA;
-    struct uint128 sigA;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    int_fast32_t expB;
-    struct uint128 sigB;
-    struct exp32_sig128 normExpSig;
-    struct uint128 rem;
-    int_fast32_t expDiff;
-    uint_fast32_t q, recip32;
-    uint_fast64_t q64;
-    struct uint128 term, altRem, meanRem;
-    bool signRem;
-    struct uint128 uiZ;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    expA  = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    expB  = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if (
-            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
-        ) {
-            goto propagateNaN;
-        }
-        goto invalid;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! (sigB.v64 | sigB.v0) ) goto invalid;
-        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! (sigA.v64 | sigA.v0) ) return a;
-        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigA.v64 |= UINT64_C( 0x0001000000000000 );
-    sigB.v64 |= UINT64_C( 0x0001000000000000 );
-    rem = sigA;
-    expDiff = expA - expB;
-    if ( expDiff < 1 ) {
-        if ( expDiff < -1 ) return a;
-        if ( expDiff ) {
-            --expB;
-            sigB = softfloat_add128( sigB.v64, sigB.v0, sigB.v64, sigB.v0 );
-            q = 0;
-        } else {
-            q = softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 );
-            if ( q ) {
-                rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-            }
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( sigB.v64>>17 );
-        expDiff -= 30;
-        for (;;) {
-            q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32;
-            if ( expDiff < 0 ) break;
-            q = (q64 + 0x80000000)>>32;
-            rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-            term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
-            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-            if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-                rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-            }
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -29 here.)
-        *--------------------------------------------------------------------*/
-        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 );
-        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
-        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
-        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            altRem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-            goto selectRem;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    do {
-        altRem = rem;
-        ++q;
-        rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
-    } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) );
- selectRem:
-    meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 );
-    if (
-        (meanRem.v64 & UINT64_C( 0x8000000000000000 ))
-            || (! (meanRem.v64 | meanRem.v0) && (q & 1))
-    ) {
-        rem = altRem;
-    }
-    signRem = signA;
-    if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
-        signRem = ! signRem;
-        rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
-    }
-    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f128_rem( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    int_fast32_t expA;
+    struct uint128 sigA;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    int_fast32_t expB;
+    struct uint128 sigB;
+    struct exp32_sig128 normExpSig;
+    struct uint128 rem;
+    int_fast32_t expDiff;
+    uint_fast32_t q, recip32;
+    uint_fast64_t q64;
+    struct uint128 term, altRem, meanRem;
+    bool signRem;
+    struct uint128 uiZ;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    expA  = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    expB  = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if (
+            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
+        ) {
+            goto propagateNaN;
+        }
+        goto invalid;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! (sigB.v64 | sigB.v0) ) goto invalid;
+        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! (sigA.v64 | sigA.v0) ) return a;
+        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigA.v64 |= UINT64_C( 0x0001000000000000 );
+    sigB.v64 |= UINT64_C( 0x0001000000000000 );
+    rem = sigA;
+    expDiff = expA - expB;
+    if ( expDiff < 1 ) {
+        if ( expDiff < -1 ) return a;
+        if ( expDiff ) {
+            --expB;
+            sigB = softfloat_add128( sigB.v64, sigB.v0, sigB.v64, sigB.v0 );
+            q = 0;
+        } else {
+            q = softfloat_le128( sigB.v64, sigB.v0, rem.v64, rem.v0 );
+            if ( q ) {
+                rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+            }
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( sigB.v64>>17 );
+        expDiff -= 30;
+        for (;;) {
+            q64 = (uint_fast64_t) (uint32_t) (rem.v64>>19) * recip32;
+            if ( expDiff < 0 ) break;
+            q = (q64 + 0x80000000)>>32;
+            rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+            term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
+            rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+            if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+                rem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+            }
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -29 here.)
+        *--------------------------------------------------------------------*/
+        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, expDiff + 30 );
+        term = softfloat_mul128By32( sigB.v64, sigB.v0, q );
+        rem = softfloat_sub128( rem.v64, rem.v0, term.v64, term.v0 );
+        if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            altRem = softfloat_add128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+            goto selectRem;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    do {
+        altRem = rem;
+        ++q;
+        rem = softfloat_sub128( rem.v64, rem.v0, sigB.v64, sigB.v0 );
+    } while ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) );
+ selectRem:
+    meanRem = softfloat_add128( rem.v64, rem.v0, altRem.v64, altRem.v0 );
+    if (
+        (meanRem.v64 & UINT64_C( 0x8000000000000000 ))
+            || (! (meanRem.v64 | meanRem.v0) && (q & 1))
+    ) {
+        rem = altRem;
+    }
+    signRem = signA;
+    if ( rem.v64 & UINT64_C( 0x8000000000000000 ) ) {
+        signRem = ! signRem;
+        rem = softfloat_sub128( 0, 0, rem.v64, rem.v0 );
+    }
+    return softfloat_normRoundPackToF128( signRem, expB - 1, rem.v64, rem.v0 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_roundToInt.c b/softfloat/source/f128_roundToInt.c
index 69185d6..96ae30e 100644
--- a/softfloat/source/f128_roundToInt.c
+++ b/softfloat/source/f128_roundToInt.c
@@ -1,172 +1,172 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t
- f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    int_fast32_t exp;
-    struct uint128 uiZ;
-    uint_fast64_t lastBitMask0, roundBitsMask;
-    bool roundNearEven;
-    uint_fast64_t lastBitMask64;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    exp = expF128UI64( uiA64 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x402F <= exp ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( 0x406F <= exp ) {
-            if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) {
-                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
-                goto uiZ;
-            }
-            return a;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        lastBitMask0 = (uint_fast64_t) 2<<(0x406E - exp);
-        roundBitsMask = lastBitMask0 - 1;
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-        roundNearEven = (roundingMode == softfloat_round_near_even);
-        if ( roundNearEven || (roundingMode == softfloat_round_near_maxMag) ) {
-            if ( exp == 0x402F ) {
-                if ( UINT64_C( 0x8000000000000000 ) <= uiZ.v0 ) {
-                    ++uiZ.v64;
-                    if (
-                        roundNearEven
-                            && (uiZ.v0 == UINT64_C( 0x8000000000000000 ))
-                    ) {
-                        uiZ.v64 &= ~1;
-                    }
-                }
-            } else {
-                uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, lastBitMask0>>1 );
-                if ( roundNearEven && !(uiZ.v0 & roundBitsMask) ) {
-                    uiZ.v0 &= ~lastBitMask0;
-                }
-            }
-        } else if (
-            roundingMode
-                == (signF128UI64( uiZ.v64 ) ? softfloat_round_min
-                        : softfloat_round_max)
-        ) {
-            uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, roundBitsMask );
-        }
-        uiZ.v0 &= ~roundBitsMask;
-        lastBitMask64 = !lastBitMask0;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( exp < 0x3FFF ) {
-            if ( !((uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF )) | uiA0) ) return a;
-            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-            uiZ.v64 = uiA64 & packToF128UI64( 1, 0, 0 );
-            uiZ.v0  = 0;
-            switch ( roundingMode ) {
-             case softfloat_round_near_even:
-                if ( !(fracF128UI64( uiA64 ) | uiA0) ) break;
-             case softfloat_round_near_maxMag:
-                if ( exp == 0x3FFE ) uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 );
-                break;
-             case softfloat_round_min:
-                if ( uiZ.v64 ) uiZ.v64 = packToF128UI64( 1, 0x3FFF, 0 );
-                break;
-             case softfloat_round_max:
-                if ( !uiZ.v64 ) uiZ.v64 = packToF128UI64( 0, 0x3FFF, 0 );
-                break;
-#ifdef SOFTFLOAT_ROUND_ODD
-             case softfloat_round_odd:
-                uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 );
-                break;
-#endif
-            }
-            goto uiZ;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        uiZ.v64 = uiA64;
-        uiZ.v0  = 0;
-        lastBitMask64 = (uint_fast64_t) 1<<(0x402F - exp);
-        roundBitsMask = lastBitMask64 - 1;
-        if ( roundingMode == softfloat_round_near_maxMag ) {
-            uiZ.v64 += lastBitMask64>>1;
-        } else if ( roundingMode == softfloat_round_near_even ) {
-            uiZ.v64 += lastBitMask64>>1;
-            if ( !((uiZ.v64 & roundBitsMask) | uiA0) ) {
-                uiZ.v64 &= ~lastBitMask64;
-            }
-        } else if (
-            roundingMode
-                == (signF128UI64( uiZ.v64 ) ? softfloat_round_min
-                        : softfloat_round_max)
-        ) {
-            uiZ.v64 = (uiZ.v64 | (uiA0 != 0)) + roundBitsMask;
-        }
-        uiZ.v64 &= ~roundBitsMask;
-        lastBitMask0 = 0;
-    }
-    if ( (uiZ.v64 != uiA64) || (uiZ.v0 != uiA0) ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            uiZ.v64 |= lastBitMask64;
-            uiZ.v0  |= lastBitMask0;
-        }
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t
+ f128_roundToInt( float128_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    int_fast32_t exp;
+    struct uint128 uiZ;
+    uint_fast64_t lastBitMask0, roundBitsMask;
+    bool roundNearEven;
+    uint_fast64_t lastBitMask64;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    exp = expF128UI64( uiA64 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x402F <= exp ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( 0x406F <= exp ) {
+            if ( (exp == 0x7FFF) && (fracF128UI64( uiA64 ) | uiA0) ) {
+                uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+                goto uiZ;
+            }
+            return a;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        lastBitMask0 = (uint_fast64_t) 2<<(0x406E - exp);
+        roundBitsMask = lastBitMask0 - 1;
+        uiZ.v64 = uiA64;
+        uiZ.v0  = uiA0;
+        roundNearEven = (roundingMode == softfloat_round_near_even);
+        if ( roundNearEven || (roundingMode == softfloat_round_near_maxMag) ) {
+            if ( exp == 0x402F ) {
+                if ( UINT64_C( 0x8000000000000000 ) <= uiZ.v0 ) {
+                    ++uiZ.v64;
+                    if (
+                        roundNearEven
+                            && (uiZ.v0 == UINT64_C( 0x8000000000000000 ))
+                    ) {
+                        uiZ.v64 &= ~1;
+                    }
+                }
+            } else {
+                uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, lastBitMask0>>1 );
+                if ( roundNearEven && !(uiZ.v0 & roundBitsMask) ) {
+                    uiZ.v0 &= ~lastBitMask0;
+                }
+            }
+        } else if (
+            roundingMode
+                == (signF128UI64( uiZ.v64 ) ? softfloat_round_min
+                        : softfloat_round_max)
+        ) {
+            uiZ = softfloat_add128( uiZ.v64, uiZ.v0, 0, roundBitsMask );
+        }
+        uiZ.v0 &= ~roundBitsMask;
+        lastBitMask64 = !lastBitMask0;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( exp < 0x3FFF ) {
+            if ( !((uiA64 & UINT64_C( 0x7FFFFFFFFFFFFFFF )) | uiA0) ) return a;
+            if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+            uiZ.v64 = uiA64 & packToF128UI64( 1, 0, 0 );
+            uiZ.v0  = 0;
+            switch ( roundingMode ) {
+             case softfloat_round_near_even:
+                if ( !(fracF128UI64( uiA64 ) | uiA0) ) break;
+             case softfloat_round_near_maxMag:
+                if ( exp == 0x3FFE ) uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 );
+                break;
+             case softfloat_round_min:
+                if ( uiZ.v64 ) uiZ.v64 = packToF128UI64( 1, 0x3FFF, 0 );
+                break;
+             case softfloat_round_max:
+                if ( !uiZ.v64 ) uiZ.v64 = packToF128UI64( 0, 0x3FFF, 0 );
+                break;
+#ifdef SOFTFLOAT_ROUND_ODD
+             case softfloat_round_odd:
+                uiZ.v64 |= packToF128UI64( 0, 0x3FFF, 0 );
+                break;
+#endif
+            }
+            goto uiZ;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        uiZ.v64 = uiA64;
+        uiZ.v0  = 0;
+        lastBitMask64 = (uint_fast64_t) 1<<(0x402F - exp);
+        roundBitsMask = lastBitMask64 - 1;
+        if ( roundingMode == softfloat_round_near_maxMag ) {
+            uiZ.v64 += lastBitMask64>>1;
+        } else if ( roundingMode == softfloat_round_near_even ) {
+            uiZ.v64 += lastBitMask64>>1;
+            if ( !((uiZ.v64 & roundBitsMask) | uiA0) ) {
+                uiZ.v64 &= ~lastBitMask64;
+            }
+        } else if (
+            roundingMode
+                == (signF128UI64( uiZ.v64 ) ? softfloat_round_min
+                        : softfloat_round_max)
+        ) {
+            uiZ.v64 = (uiZ.v64 | (uiA0 != 0)) + roundBitsMask;
+        }
+        uiZ.v64 &= ~roundBitsMask;
+        lastBitMask0 = 0;
+    }
+    if ( (uiZ.v64 != uiA64) || (uiZ.v0 != uiA0) ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            uiZ.v64 |= lastBitMask64;
+            uiZ.v0  |= lastBitMask0;
+        }
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_sqrt.c b/softfloat/source/f128_sqrt.c
index f1d9bac..a32fe33 100644
--- a/softfloat/source/f128_sqrt.c
+++ b/softfloat/source/f128_sqrt.c
@@ -1,201 +1,201 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f128_sqrt( float128_t a )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    int_fast32_t expA;
-    struct uint128 sigA, uiZ;
-    struct exp32_sig128 normExpSig;
-    int_fast32_t expZ;
-    uint_fast32_t sig32A, recipSqrt32, sig32Z;
-    struct uint128 rem;
-    uint32_t qs[3];
-    uint_fast32_t q;
-    uint_fast64_t x64, sig64Z;
-    struct uint128 y, term;
-    uint_fast64_t sigZExtra;
-    struct uint128 sigZ;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    expA  = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if ( sigA.v64 | sigA.v0 ) {
-            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
-            goto uiZ;
-        }
-        if ( ! signA ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signA ) {
-        if ( ! (expA | sigA.v64 | sigA.v0) ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! (sigA.v64 | sigA.v0) ) return a;
-        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    | (`sig32Z' is guaranteed to be a lower bound on the square root of
-    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
-    | `sigA'.)
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
-    expA &= 1;
-    sigA.v64 |= UINT64_C( 0x0001000000000000 );
-    sig32A = sigA.v64>>17;
-    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
-    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
-    if ( expA ) {
-        sig32Z >>= 1;
-        rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 12 );
-    } else {
-        rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 13 );
-    }
-    qs[2] = sig32Z;
-    rem.v64 -= (uint_fast64_t) sig32Z * sig32Z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32;
-    x64 = (uint_fast64_t) sig32Z<<32;
-    sig64Z = x64 + ((uint_fast64_t) q<<3);
-    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        term = softfloat_mul64ByShifted32To128( x64 + sig64Z, q );
-        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
-        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
-        --q;
-        sig64Z -= 1<<3;
-    }
-    qs[1] = q;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = ((rem.v64>>2) * recipSqrt32)>>32;
-    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
-    sig64Z <<= 1;
-    /*------------------------------------------------------------------------
-    | (Repeating this loop is a rare occurrence.)
-    *------------------------------------------------------------------------*/
-    for (;;) {
-        term = softfloat_shortShiftLeft128( 0, sig64Z, 32 );
-        term = softfloat_add128( term.v64, term.v0, 0, (uint_fast64_t) q<<6 );
-        term = softfloat_mul128By32( term.v64, term.v0, q );
-        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
-        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
-        --q;
-    }
-    qs[0] = q;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    q = (((rem.v64>>2) * recipSqrt32)>>32) + 2;
-    sigZExtra = (uint64_t) ((uint_fast64_t) q<<59);
-    term = softfloat_shortShiftLeft128( 0, qs[1], 53 );
-    sigZ =
-        softfloat_add128(
-            (uint_fast64_t) qs[2]<<18, ((uint_fast64_t) qs[0]<<24) + (q>>5),
-            term.v64, term.v0
-        );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (q & 0xF) <= 2 ) {
-        q &= ~3;
-        sigZExtra = (uint64_t) ((uint_fast64_t) q<<59);
-        y = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, 6 );
-        y.v0 |= sigZExtra>>58;
-        term = softfloat_sub128( y.v64, y.v0, 0, q );
-        y    = softfloat_mul64ByShifted32To128( term.v0,  q );
-        term = softfloat_mul64ByShifted32To128( term.v64, q );
-        term = softfloat_add128( term.v64, term.v0, 0, y.v64 );
-        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 20 );
-        term = softfloat_sub128( term.v64, term.v0, rem.v64, rem.v0 );
-        /*--------------------------------------------------------------------
-        | The concatenation of `term' and `y.v0' is now the negative remainder
-        | (3 words altogether).
-        *--------------------------------------------------------------------*/
-        if ( term.v64 & UINT64_C( 0x8000000000000000 ) ) {
-            sigZExtra |= 1;
-        } else {
-            if ( term.v64 | term.v0 | y.v0 ) {
-                if ( sigZExtra ) {
-                    --sigZExtra;
-                } else {
-                    sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 );
-                    sigZExtra = ~0;
-                }
-            }
-        }
-    }
-    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f128_sqrt( float128_t a )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    int_fast32_t expA;
+    struct uint128 sigA, uiZ;
+    struct exp32_sig128 normExpSig;
+    int_fast32_t expZ;
+    uint_fast32_t sig32A, recipSqrt32, sig32Z;
+    struct uint128 rem;
+    uint32_t qs[3];
+    uint_fast32_t q;
+    uint_fast64_t x64, sig64Z;
+    struct uint128 y, term;
+    uint_fast64_t sigZExtra;
+    struct uint128 sigZ;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    expA  = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if ( sigA.v64 | sigA.v0 ) {
+            uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, 0, 0 );
+            goto uiZ;
+        }
+        if ( ! signA ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signA ) {
+        if ( ! (expA | sigA.v64 | sigA.v0) ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! (sigA.v64 | sigA.v0) ) return a;
+        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    | (`sig32Z' is guaranteed to be a lower bound on the square root of
+    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+    | `sigA'.)
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x3FFF)>>1) + 0x3FFE;
+    expA &= 1;
+    sigA.v64 |= UINT64_C( 0x0001000000000000 );
+    sig32A = sigA.v64>>17;
+    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
+    if ( expA ) {
+        sig32Z >>= 1;
+        rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 12 );
+    } else {
+        rem = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 13 );
+    }
+    qs[2] = sig32Z;
+    rem.v64 -= (uint_fast64_t) sig32Z * sig32Z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((uint32_t) (rem.v64>>2) * (uint_fast64_t) recipSqrt32)>>32;
+    x64 = (uint_fast64_t) sig32Z<<32;
+    sig64Z = x64 + ((uint_fast64_t) q<<3);
+    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        term = softfloat_mul64ByShifted32To128( x64 + sig64Z, q );
+        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
+        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
+        --q;
+        sig64Z -= 1<<3;
+    }
+    qs[1] = q;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = ((rem.v64>>2) * recipSqrt32)>>32;
+    y = softfloat_shortShiftLeft128( rem.v64, rem.v0, 29 );
+    sig64Z <<= 1;
+    /*------------------------------------------------------------------------
+    | (Repeating this loop is a rare occurrence.)
+    *------------------------------------------------------------------------*/
+    for (;;) {
+        term = softfloat_shortShiftLeft128( 0, sig64Z, 32 );
+        term = softfloat_add128( term.v64, term.v0, 0, (uint_fast64_t) q<<6 );
+        term = softfloat_mul128By32( term.v64, term.v0, q );
+        rem = softfloat_sub128( y.v64, y.v0, term.v64, term.v0 );
+        if ( ! (rem.v64 & UINT64_C( 0x8000000000000000 )) ) break;
+        --q;
+    }
+    qs[0] = q;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    q = (((rem.v64>>2) * recipSqrt32)>>32) + 2;
+    sigZExtra = (uint64_t) ((uint_fast64_t) q<<59);
+    term = softfloat_shortShiftLeft128( 0, qs[1], 53 );
+    sigZ =
+        softfloat_add128(
+            (uint_fast64_t) qs[2]<<18, ((uint_fast64_t) qs[0]<<24) + (q>>5),
+            term.v64, term.v0
+        );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (q & 0xF) <= 2 ) {
+        q &= ~3;
+        sigZExtra = (uint64_t) ((uint_fast64_t) q<<59);
+        y = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, 6 );
+        y.v0 |= sigZExtra>>58;
+        term = softfloat_sub128( y.v64, y.v0, 0, q );
+        y    = softfloat_mul64ByShifted32To128( term.v0,  q );
+        term = softfloat_mul64ByShifted32To128( term.v64, q );
+        term = softfloat_add128( term.v64, term.v0, 0, y.v64 );
+        rem = softfloat_shortShiftLeft128( rem.v64, rem.v0, 20 );
+        term = softfloat_sub128( term.v64, term.v0, rem.v64, rem.v0 );
+        /*--------------------------------------------------------------------
+        | The concatenation of `term' and `y.v0' is now the negative remainder
+        | (3 words altogether).
+        *--------------------------------------------------------------------*/
+        if ( term.v64 & UINT64_C( 0x8000000000000000 ) ) {
+            sigZExtra |= 1;
+        } else {
+            if ( term.v64 | term.v0 | y.v0 ) {
+                if ( sigZExtra ) {
+                    --sigZExtra;
+                } else {
+                    sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 );
+                    sigZExtra = ~0;
+                }
+            }
+        }
+    }
+    return softfloat_roundPackToF128( 0, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_sub.c b/softfloat/source/f128_sub.c
index 5181cc5..ef76ac4 100644
--- a/softfloat/source/f128_sub.c
+++ b/softfloat/source/f128_sub.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t f128_sub( float128_t a, float128_t b )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool signA;
-    union ui128_f128 uB;
-    uint_fast64_t uiB64, uiB0;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float128_t
-        (*magsFuncPtr)(
-            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    signA = signF128UI64( uiA64 );
-    uB.f = b;
-    uiB64 = uB.ui.v64;
-    uiB0  = uB.ui.v0;
-    signB = signF128UI64( uiB64 );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    } else {
-        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
-    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t f128_sub( float128_t a, float128_t b )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool signA;
+    union ui128_f128 uB;
+    uint_fast64_t uiB64, uiB0;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float128_t
+        (*magsFuncPtr)(
+            uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    signA = signF128UI64( uiA64 );
+    uB.f = b;
+    uiB64 = uB.ui.v64;
+    uiB0  = uB.ui.v0;
+    signB = signF128UI64( uiB64 );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_subMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    } else {
+        return softfloat_addMagsF128( uiA64, uiA0, uiB64, uiB0, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_subMagsF128 : softfloat_addMagsF128;
+    return (*magsFuncPtr)( uiA64, uiA0, uiB64, uiB0, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/f128_to_extF80.c b/softfloat/source/f128_to_extF80.c
index ec169c0..cb0a6ce 100644
--- a/softfloat/source/f128_to_extF80.c
+++ b/softfloat/source/f128_to_extF80.c
@@ -1,109 +1,109 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t f128_to_extF80( float128_t a )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t frac64, frac0;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    struct exp32_sig128 normExpSig;
-    struct uint128 sig128;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign   = signF128UI64( uiA64 );
-    exp    = expF128UI64( uiA64 );
-    frac64 = fracF128UI64( uiA64 );
-    frac0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
-            uiZ64 = uiZ.v64;
-            uiZ0  = uiZ.v0;
-        } else {
-            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-            uiZ0  = UINT64_C( 0x8000000000000000 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! (frac64 | frac0) ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF128Sig( frac64, frac0 );
-        exp   = normExpSig.exp;
-        frac64 = normExpSig.sig.v64;
-        frac0  = normExpSig.sig.v0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig128 =
-        softfloat_shortShiftLeft128(
-            frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 );
-    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t f128_to_extF80( float128_t a )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t frac64, frac0;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    struct exp32_sig128 normExpSig;
+    struct uint128 sig128;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign   = signF128UI64( uiA64 );
+    exp    = expF128UI64( uiA64 );
+    frac64 = fracF128UI64( uiA64 );
+    frac0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 | frac0 ) {
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
+            uiZ64 = uiZ.v64;
+            uiZ0  = uiZ.v0;
+        } else {
+            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+            uiZ0  = UINT64_C( 0x8000000000000000 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! (frac64 | frac0) ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF128Sig( frac64, frac0 );
+        exp   = normExpSig.exp;
+        frac64 = normExpSig.sig.v64;
+        frac0  = normExpSig.sig.v0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig128 =
+        softfloat_shortShiftLeft128(
+            frac64 | UINT64_C( 0x0001000000000000 ), frac0, 15 );
+    return softfloat_roundPackToExtF80( sign, exp, sig128.v64, sig128.v0, 80 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_to_f16.c b/softfloat/source/f128_to_f16.c
index 5a8ee72..62ed35b 100644
--- a/softfloat/source/f128_to_f16.c
+++ b/softfloat/source/f128_to_f16.c
@@ -1,95 +1,95 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f128_to_f16( float128_t a )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t frac64;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ, frac16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac16 = softfloat_shortShiftRightJam64( frac64, 34 );
-    if ( ! (exp | frac16) ) {
-        uiZ = packToF16UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3FF1;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x40 ) exp = -0x40;
-    }
-    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f128_to_f16( float128_t a )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t frac64;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ, frac16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 ) {
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac16 = softfloat_shortShiftRightJam64( frac64, 34 );
+    if ( ! (exp | frac16) ) {
+        uiZ = packToF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3FF1;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x40 ) exp = -0x40;
+    }
+    return softfloat_roundPackToF16( sign, exp, frac16 | 0x4000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_to_f32.c b/softfloat/source/f128_to_f32.c
index 07e4a80..c10105f 100644
--- a/softfloat/source/f128_to_f32.c
+++ b/softfloat/source/f128_to_f32.c
@@ -1,95 +1,95 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f128_to_f32( float128_t a )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t frac64;
-    struct commonNaN commonNaN;
-    uint_fast32_t uiZ, frac32;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
-    if ( ! (exp | frac32) ) {
-        uiZ = packToF32UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3F81;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f128_to_f32( float128_t a )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t frac64;
+    struct commonNaN commonNaN;
+    uint_fast32_t uiZ, frac32;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    frac64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 ) {
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac32 = softfloat_shortShiftRightJam64( frac64, 18 );
+    if ( ! (exp | frac32) ) {
+        uiZ = packToF32UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3F81;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return softfloat_roundPackToF32( sign, exp, frac32 | 0x40000000 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_to_f64.c b/softfloat/source/f128_to_f64.c
index f791938..76da76c 100644
--- a/softfloat/source/f128_to_f64.c
+++ b/softfloat/source/f128_to_f64.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f128_to_f64( float128_t a )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t frac64, frac0;
-    struct commonNaN commonNaN;
-    uint_fast64_t uiZ;
-    struct uint128 frac128;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    frac64 = fracF128UI64( uiA64 );
-    frac0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FFF ) {
-        if ( frac64 | frac0 ) {
-            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac128 = softfloat_shortShiftLeft128( frac64, frac0, 14 );
-    frac64 = frac128.v64 | (frac128.v0 != 0);
-    if ( ! (exp | frac64) ) {
-        uiZ = packToF64UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    exp -= 0x3C01;
-    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
-        if ( exp < -0x1000 ) exp = -0x1000;
-    }
-    return
-        softfloat_roundPackToF64(
-            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f128_to_f64( float128_t a )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t frac64, frac0;
+    struct commonNaN commonNaN;
+    uint_fast64_t uiZ;
+    struct uint128 frac128;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    frac64 = fracF128UI64( uiA64 );
+    frac0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FFF ) {
+        if ( frac64 | frac0 ) {
+            softfloat_f128UIToCommonNaN( uiA64, uiA0, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac128 = softfloat_shortShiftLeft128( frac64, frac0, 14 );
+    frac64 = frac128.v64 | (frac128.v0 != 0);
+    if ( ! (exp | frac64) ) {
+        uiZ = packToF64UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    exp -= 0x3C01;
+    if ( sizeof (int_fast16_t) < sizeof (int_fast32_t) ) {
+        if ( exp < -0x1000 ) exp = -0x1000;
+    }
+    return
+        softfloat_roundPackToF64(
+            sign, exp, frac64 | UINT64_C( 0x4000000000000000 ) );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f128_to_i32.c b/softfloat/source/f128_to_i32.c
index 16c4a3c..cfff04a 100644
--- a/softfloat/source/f128_to_i32.c
+++ b/softfloat/source/f128_to_i32.c
@@ -1,85 +1,85 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64, sig0;
-    int_fast32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 );
-    sig0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && (sig64 | sig0) ) {
-#if (i32_fromNaN == i32_fromPosOverflow)
-        sign = 0;
-#elif (i32_fromNaN == i32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return i32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-    sig64 |= (sig0 != 0);
-    shiftDist = 0x4023 - exp;
-    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f128_to_i32( float128_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64, sig0;
+    int_fast32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 );
+    sig0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && (sig64 | sig0) ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+        sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return i32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+    sig64 |= (sig0 != 0);
+    shiftDist = 0x4023 - exp;
+    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f128_to_i32_r_minMag.c b/softfloat/source/f128_to_i32_r_minMag.c
index 18cfeae..161b675 100644
--- a/softfloat/source/f128_to_i32_r_minMag.c
+++ b/softfloat/source/f128_to_i32_r_minMag.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    int_fast32_t exp;
-    uint_fast64_t sig64;
-    int_fast32_t shiftDist;
-    bool sign;
-    int_fast32_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( 49 <= shiftDist ) {
-        if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF128UI64( uiA64 );
-    if ( shiftDist < 18 ) {
-        if (
-            sign && (shiftDist == 17)
-                && (sig64 < UINT64_C( 0x0000000000020000 ))
-        ) {
-            if ( exact && sig64 ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return -0x7FFFFFFF - 1;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && sig64 ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig64 |= UINT64_C( 0x0001000000000000 );
-    absZ = sig64>>shiftDist;
-    if (
-        exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig64)
-    ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f128_to_i32_r_minMag( float128_t a, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    int_fast32_t exp;
+    uint_fast64_t sig64;
+    int_fast32_t shiftDist;
+    bool sign;
+    int_fast32_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( 49 <= shiftDist ) {
+        if ( exact && (exp | sig64) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF128UI64( uiA64 );
+    if ( shiftDist < 18 ) {
+        if (
+            sign && (shiftDist == 17)
+                && (sig64 < UINT64_C( 0x0000000000020000 ))
+        ) {
+            if ( exact && sig64 ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return -0x7FFFFFFF - 1;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && sig64 ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig64 |= UINT64_C( 0x0001000000000000 );
+    absZ = sig64>>shiftDist;
+    if (
+        exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig64)
+    ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f128_to_i64.c b/softfloat/source/f128_to_i64.c
index f554660..2ff4740 100644
--- a/softfloat/source/f128_to_i64.c
+++ b/softfloat/source/f128_to_i64.c
@@ -1,95 +1,95 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64, sig0;
-    int_fast32_t shiftDist;
-    struct uint128 sig128;
-    struct uint64_extra sigExtra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 );
-    sig0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( shiftDist <= 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            return
-                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
-                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        if ( shiftDist ) {
-            sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist );
-            sig64 = sig128.v64;
-            sig0  = sig128.v0;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-        sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist );
-        sig64 = sigExtra.v;
-        sig0  = sigExtra.extra;
-    }
-    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f128_to_i64( float128_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64, sig0;
+    int_fast32_t shiftDist;
+    struct uint128 sig128;
+    struct uint64_extra sigExtra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 );
+    sig0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( shiftDist <= 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( shiftDist < -15 ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            return
+                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
+                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        if ( shiftDist ) {
+            sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist );
+            sig64 = sig128.v64;
+            sig0  = sig128.v0;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+        sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist );
+        sig64 = sigExtra.v;
+        sig0  = sigExtra.extra;
+    }
+    return softfloat_roundToI64( sign, sig64, sig0, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f128_to_i64_r_minMag.c b/softfloat/source/f128_to_i64_r_minMag.c
index e2cc62e..dc44e7a 100644
--- a/softfloat/source/f128_to_i64_r_minMag.c
+++ b/softfloat/source/f128_to_i64_r_minMag.c
@@ -1,113 +1,113 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64, sig0;
-    int_fast32_t shiftDist;
-    int_fast8_t negShiftDist;
-    int_fast64_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 );
-    sig0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( shiftDist < 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( shiftDist < -14 ) {
-            if (
-                   (uiA64 == UINT64_C( 0xC03E000000000000 ))
-                && (sig0 < UINT64_C( 0x0002000000000000 ))
-            ) {
-                if ( exact && sig0 ) {
-                    softfloat_exceptionFlags |= softfloat_flag_inexact;
-                }
-                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
-            }
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            return
-                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
-                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        negShiftDist = -shiftDist;
-        absZ = sig64<<negShiftDist | sig0>>(shiftDist & 63);
-        if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( 49 <= shiftDist ) {
-            if ( exact && (exp | sig64 | sig0) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return 0;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        absZ = sig64>>shiftDist;
-        if ( exact && (sig0 || (absZ<<shiftDist != sig64)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f128_to_i64_r_minMag( float128_t a, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64, sig0;
+    int_fast32_t shiftDist;
+    int_fast8_t negShiftDist;
+    int_fast64_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 );
+    sig0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( shiftDist < 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( shiftDist < -14 ) {
+            if (
+                   (uiA64 == UINT64_C( 0xC03E000000000000 ))
+                && (sig0 < UINT64_C( 0x0002000000000000 ))
+            ) {
+                if ( exact && sig0 ) {
+                    softfloat_exceptionFlags |= softfloat_flag_inexact;
+                }
+                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
+            }
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            return
+                (exp == 0x7FFF) && (sig64 | sig0) ? i64_fromNaN
+                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        negShiftDist = -shiftDist;
+        absZ = sig64<<negShiftDist | sig0>>(shiftDist & 63);
+        if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( 49 <= shiftDist ) {
+            if ( exact && (exp | sig64 | sig0) ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return 0;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        absZ = sig64>>shiftDist;
+        if ( exact && (sig0 || (absZ<<shiftDist != sig64)) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f128_to_ui32.c b/softfloat/source/f128_to_ui32.c
index 7d8f3f8..54b07d6 100644
--- a/softfloat/source/f128_to_ui32.c
+++ b/softfloat/source/f128_to_ui32.c
@@ -1,86 +1,86 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t
- f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64;
-    int_fast32_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
-    if ( (exp == 0x7FFF) && sig64 ) {
-#if (ui32_fromNaN == ui32_fromPosOverflow)
-        sign = 0;
-#elif (ui32_fromNaN == ui32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return ui32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-    shiftDist = 0x4023 - exp;
-    if ( 0 < shiftDist ) {
-        sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    }
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t
+ f128_to_ui32( float128_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64;
+    int_fast32_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+    if ( (exp == 0x7FFF) && sig64 ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+        sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return ui32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+    shiftDist = 0x4023 - exp;
+    if ( 0 < shiftDist ) {
+        sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    }
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f128_to_ui32_r_minMag.c b/softfloat/source/f128_to_ui32_r_minMag.c
index 92facd5..650c18f 100644
--- a/softfloat/source/f128_to_ui32_r_minMag.c
+++ b/softfloat/source/f128_to_ui32_r_minMag.c
@@ -1,89 +1,89 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    int_fast32_t exp;
-    uint_fast64_t sig64;
-    int_fast32_t shiftDist;
-    bool sign;
-    uint_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( 49 <= shiftDist ) {
-        if ( exact && (exp | sig64) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF128UI64( uiA64 );
-    if ( sign || (shiftDist < 17) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FFF) && sig64 ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig64 |= UINT64_C( 0x0001000000000000 );
-    z = sig64>>shiftDist;
-    if ( exact && ((uint_fast64_t) z<<shiftDist != sig64) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f128_to_ui32_r_minMag( float128_t a, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    int_fast32_t exp;
+    uint_fast64_t sig64;
+    int_fast32_t shiftDist;
+    bool sign;
+    uint_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 ) | (uiA0 != 0);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( 49 <= shiftDist ) {
+        if ( exact && (exp | sig64) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF128UI64( uiA64 );
+    if ( sign || (shiftDist < 17) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FFF) && sig64 ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig64 |= UINT64_C( 0x0001000000000000 );
+    z = sig64>>shiftDist;
+    if ( exact && ((uint_fast64_t) z<<shiftDist != sig64) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/f128_to_ui64.c b/softfloat/source/f128_to_ui64.c
index 3c38882..7576992 100644
--- a/softfloat/source/f128_to_ui64.c
+++ b/softfloat/source/f128_to_ui64.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t
- f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64, sig0;
-    int_fast32_t shiftDist;
-    struct uint128 sig128;
-    struct uint64_extra sigExtra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 );
-    sig0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( shiftDist <= 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( shiftDist < -15 ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            return
-                (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
-                    : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        if ( shiftDist ) {
-            sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist );
-            sig64 = sig128.v64;
-            sig0  = sig128.v0;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
-        sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist );
-        sig64 = sigExtra.v;
-        sig0  = sigExtra.extra;
-    }
-    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t
+ f128_to_ui64( float128_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64, sig0;
+    int_fast32_t shiftDist;
+    struct uint128 sig128;
+    struct uint64_extra sigExtra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 );
+    sig0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( shiftDist <= 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( shiftDist < -15 ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            return
+                (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
+                    : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        if ( shiftDist ) {
+            sig128 = softfloat_shortShiftLeft128( sig64, sig0, -shiftDist );
+            sig64 = sig128.v64;
+            sig0  = sig128.v0;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( exp ) sig64 |= UINT64_C( 0x0001000000000000 );
+        sigExtra = softfloat_shiftRightJam64Extra( sig64, sig0, shiftDist );
+        sig64 = sigExtra.v;
+        sig0  = sigExtra.extra;
+    }
+    return softfloat_roundToUI64( sign, sig64, sig0, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f128_to_ui64_r_minMag.c b/softfloat/source/f128_to_ui64_r_minMag.c
index edeafd3..3f2fb6b 100644
--- a/softfloat/source/f128_to_ui64_r_minMag.c
+++ b/softfloat/source/f128_to_ui64_r_minMag.c
@@ -1,105 +1,105 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
-{
-    union ui128_f128 uA;
-    uint_fast64_t uiA64, uiA0;
-    bool sign;
-    int_fast32_t exp;
-    uint_fast64_t sig64, sig0;
-    int_fast32_t shiftDist;
-    int_fast8_t negShiftDist;
-    uint_fast64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA64 = uA.ui.v64;
-    uiA0  = uA.ui.v0;
-    sign  = signF128UI64( uiA64 );
-    exp   = expF128UI64( uiA64 );
-    sig64 = fracF128UI64( uiA64 );
-    sig0  = uiA0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x402F - exp;
-    if ( shiftDist < 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( sign || (shiftDist < -15) ) goto invalid;
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        negShiftDist = -shiftDist;
-        z = sig64<<negShiftDist | sig0>>(shiftDist & 63);
-        if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( 49 <= shiftDist ) {
-            if ( exact && (exp | sig64 | sig0) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return 0;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( sign ) goto invalid;
-        sig64 |= UINT64_C( 0x0001000000000000 );
-        z = sig64>>shiftDist;
-        if ( exact && (sig0 || (z<<shiftDist != sig64)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
-            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f128_to_ui64_r_minMag( float128_t a, bool exact )
+{
+    union ui128_f128 uA;
+    uint_fast64_t uiA64, uiA0;
+    bool sign;
+    int_fast32_t exp;
+    uint_fast64_t sig64, sig0;
+    int_fast32_t shiftDist;
+    int_fast8_t negShiftDist;
+    uint_fast64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA64 = uA.ui.v64;
+    uiA0  = uA.ui.v0;
+    sign  = signF128UI64( uiA64 );
+    exp   = expF128UI64( uiA64 );
+    sig64 = fracF128UI64( uiA64 );
+    sig0  = uiA0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x402F - exp;
+    if ( shiftDist < 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( sign || (shiftDist < -15) ) goto invalid;
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        negShiftDist = -shiftDist;
+        z = sig64<<negShiftDist | sig0>>(shiftDist & 63);
+        if ( exact && (uint64_t) (sig0<<negShiftDist) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( 49 <= shiftDist ) {
+            if ( exact && (exp | sig64 | sig0) ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return 0;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( sign ) goto invalid;
+        sig64 |= UINT64_C( 0x0001000000000000 );
+        z = sig64>>shiftDist;
+        if ( exact && (sig0 || (z<<shiftDist != sig64)) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FFF) && (sig64 | sig0) ? ui64_fromNaN
+            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/f16_add.c b/softfloat/source/f16_add.c
index ff6ec25..16e8063 100644
--- a/softfloat/source/f16_add.c
+++ b/softfloat/source/f16_add.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t f16_add( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
-    if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF16( uiA, uiB );
-    } else {
-        return softfloat_addMagsF16( uiA, uiB );
-    }
-#else
-    magsFuncPtr =
-        signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t f16_add( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
+    if ( signF16UI( uiA ^ uiB ) ) {
+        return softfloat_subMagsF16( uiA, uiB );
+    } else {
+        return softfloat_addMagsF16( uiA, uiB );
+    }
+#else
+    magsFuncPtr =
+        signF16UI( uiA ^ uiB ) ? softfloat_subMagsF16 : softfloat_addMagsF16;
+    return (*magsFuncPtr)( uiA, uiB );
+#endif
+
+}
+
diff --git a/softfloat/source/f16_div.c b/softfloat/source/f16_div.c
index 77f9a2c..ad91a90 100644
--- a/softfloat/source/f16_div.c
+++ b/softfloat/source/f16_div.c
@@ -1,186 +1,186 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extern const uint16_t softfloat_approxRecip_1k0s[];
-extern const uint16_t softfloat_approxRecip_1k1s[];
-
-float16_t f16_div( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool signA;
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signB;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    bool signZ;
-    struct exp8_sig16 normExpSig;
-    int_fast8_t expZ;
-#ifdef SOFTFLOAT_FAST_DIV32TO16
-    uint_fast32_t sig32A;
-    uint_fast16_t sigZ;
-#else
-    int index;
-    uint16_t r0;
-    uint_fast16_t sigZ, rem;
-#endif
-    uint_fast16_t uiZ;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF16UI( uiA );
-    expA  = expF16UI( uiA );
-    sigA  = fracF16UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF16UI( uiB );
-    expB  = expF16UI( uiB );
-    sigB  = fracF16UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x1F ) {
-        if ( sigA ) goto propagateNaN;
-        if ( expB == 0x1F ) {
-            if ( sigB ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0x1F ) {
-        if ( sigB ) goto propagateNaN;
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) {
-            if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF16Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0xE;
-    sigA |= 0x0400;
-    sigB |= 0x0400;
-#ifdef SOFTFLOAT_FAST_DIV32TO16
-    if ( sigA < sigB ) {
-        --expZ;
-        sig32A = (uint_fast32_t) sigA<<15;
-    } else {
-        sig32A = (uint_fast32_t) sigA<<14;
-    }
-    sigZ = sig32A / sigB;
-    if ( ! (sigZ & 7) ) sigZ |= ((uint_fast32_t) sigB * sigZ != sig32A);
-#else
-    if ( sigA < sigB ) {
-        --expZ;
-        sigA <<= 5;
-    } else {
-        sigA <<= 4;
-    }
-    index = sigB>>6 & 0xF;
-    r0 = softfloat_approxRecip_1k0s[index]
-             - (((uint_fast32_t) softfloat_approxRecip_1k1s[index]
-                     * (sigB & 0x3F))
-                    >>10);
-    sigZ = ((uint_fast32_t) sigA * r0)>>16;
-    rem = (sigA<<10) - sigZ * sigB;
-    sigZ += (rem * (uint_fast32_t) r0)>>26;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    ++sigZ;
-    if ( ! (sigZ & 7) ) {
-        sigZ &= ~1;
-        rem = (sigA<<10) - sigZ * sigB;
-        if ( rem & 0x8000 ) {
-            sigZ -= 2;
-        } else {
-            if ( rem ) sigZ |= 1;
-        }
-    }
-#endif
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF16UI;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ = packToF16UI( signZ, 0x1F, 0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF16UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extern const uint16_t softfloat_approxRecip_1k0s[];
+extern const uint16_t softfloat_approxRecip_1k1s[];
+
+float16_t f16_div( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signB;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    bool signZ;
+    struct exp8_sig16 normExpSig;
+    int_fast8_t expZ;
+#ifdef SOFTFLOAT_FAST_DIV32TO16
+    uint_fast32_t sig32A;
+    uint_fast16_t sigZ;
+#else
+    int index;
+    uint16_t r0;
+    uint_fast16_t sigZ, rem;
+#endif
+    uint_fast16_t uiZ;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF16UI( uiB );
+    expB  = expF16UI( uiB );
+    sigB  = fracF16UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA ) goto propagateNaN;
+        if ( expB == 0x1F ) {
+            if ( sigB ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0x1F ) {
+        if ( sigB ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) {
+            if ( ! (expA | sigA) ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0xE;
+    sigA |= 0x0400;
+    sigB |= 0x0400;
+#ifdef SOFTFLOAT_FAST_DIV32TO16
+    if ( sigA < sigB ) {
+        --expZ;
+        sig32A = (uint_fast32_t) sigA<<15;
+    } else {
+        sig32A = (uint_fast32_t) sigA<<14;
+    }
+    sigZ = sig32A / sigB;
+    if ( ! (sigZ & 7) ) sigZ |= ((uint_fast32_t) sigB * sigZ != sig32A);
+#else
+    if ( sigA < sigB ) {
+        --expZ;
+        sigA <<= 5;
+    } else {
+        sigA <<= 4;
+    }
+    index = sigB>>6 & 0xF;
+    r0 = softfloat_approxRecip_1k0s[index]
+             - (((uint_fast32_t) softfloat_approxRecip_1k1s[index]
+                     * (sigB & 0x3F))
+                    >>10);
+    sigZ = ((uint_fast32_t) sigA * r0)>>16;
+    rem = (sigA<<10) - sigZ * sigB;
+    sigZ += (rem * (uint_fast32_t) r0)>>26;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    ++sigZ;
+    if ( ! (sigZ & 7) ) {
+        sigZ &= ~1;
+        rem = (sigA<<10) - sigZ * sigB;
+        if ( rem & 0x8000 ) {
+            sigZ -= 2;
+        } else {
+            if ( rem ) sigZ |= 1;
+        }
+    }
+#endif
+    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF16UI;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ = packToF16UI( signZ, 0x1F, 0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF16UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_eq.c b/softfloat/source/f16_eq.c
index 692fa03..4079f50 100644
--- a/softfloat/source/f16_eq.c
+++ b/softfloat/source/f16_eq.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f16_eq( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f16_eq( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1);
+
+}
+
diff --git a/softfloat/source/f16_eq_signaling.c b/softfloat/source/f16_eq_signaling.c
index c1e7a50..117d05d 100644
--- a/softfloat/source/f16_eq_signaling.c
+++ b/softfloat/source/f16_eq_signaling.c
@@ -1,61 +1,61 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f16_eq_signaling( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f16_eq_signaling( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    return (uiA == uiB) || ! (uint16_t) ((uiA | uiB)<<1);
+
+}
+
diff --git a/softfloat/source/f16_isSignalingNaN.c b/softfloat/source/f16_isSignalingNaN.c
index 3eb3d4c..c49e0f2 100644
--- a/softfloat/source/f16_isSignalingNaN.c
+++ b/softfloat/source/f16_isSignalingNaN.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f16_isSignalingNaN( float16_t a )
-{
-    union ui16_f16 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF16UI( uA.ui );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f16_isSignalingNaN( float16_t a )
+{
+    union ui16_f16 uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNF16UI( uA.ui );
+
+}
+
diff --git a/softfloat/source/f16_le.c b/softfloat/source/f16_le.c
index d7313de..fa69432 100644
--- a/softfloat/source/f16_le.c
+++ b/softfloat/source/f16_le.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f16_le( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF16UI( uiA );
-    signB = signF16UI( uiB );
-    return
-        (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f16_le( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF16UI( uiA );
+    signB = signF16UI( uiB );
+    return
+        (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f16_le_quiet.c b/softfloat/source/f16_le_quiet.c
index 15181c2..769a1dc 100644
--- a/softfloat/source/f16_le_quiet.c
+++ b/softfloat/source/f16_le_quiet.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f16_le_quiet( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF16UI( uiA );
-    signB = signF16UI( uiB );
-    return
-        (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f16_le_quiet( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF16UI( uiA );
+    signB = signF16UI( uiB );
+    return
+        (signA != signB) ? signA || ! (uint16_t) ((uiA | uiB)<<1)
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f16_lt.c b/softfloat/source/f16_lt.c
index 7745699..e796016 100644
--- a/softfloat/source/f16_lt.c
+++ b/softfloat/source/f16_lt.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f16_lt( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF16UI( uiA );
-    signB = signF16UI( uiB );
-    return
-        (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f16_lt( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF16UI( uiA );
+    signB = signF16UI( uiB );
+    return
+        (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f16_lt_quiet.c b/softfloat/source/f16_lt_quiet.c
index a31e4a1..c55bade 100644
--- a/softfloat/source/f16_lt_quiet.c
+++ b/softfloat/source/f16_lt_quiet.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f16_lt_quiet( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF16UI( uiA );
-    signB = signF16UI( uiB );
-    return
-        (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f16_lt_quiet( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF16UI( uiA ) || isNaNF16UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF16UI( uiA ) || softfloat_isSigNaNF16UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF16UI( uiA );
+    signB = signF16UI( uiB );
+    return
+        (signA != signB) ? signA && ((uint16_t) ((uiA | uiB)<<1) != 0)
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f16_mul.c b/softfloat/source/f16_mul.c
index a47cab8..112111d 100644
--- a/softfloat/source/f16_mul.c
+++ b/softfloat/source/f16_mul.c
@@ -1,140 +1,140 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f16_mul( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool signA;
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    bool signB;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    bool signZ;
-    uint_fast16_t magBits;
-    struct exp8_sig16 normExpSig;
-    int_fast8_t expZ;
-    uint_fast32_t sig32Z;
-    uint_fast16_t sigZ, uiZ;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF16UI( uiA );
-    expA  = expF16UI( uiA );
-    sigA  = fracF16UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF16UI( uiB );
-    expB  = expF16UI( uiB );
-    sigB  = fracF16UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x1F ) {
-        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
-        magBits = expB | sigB;
-        goto infArg;
-    }
-    if ( expB == 0x1F ) {
-        if ( sigB ) goto propagateNaN;
-        magBits = expA | sigA;
-        goto infArg;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF16Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zero;
-        normExpSig = softfloat_normSubnormalF16Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0xF;
-    sigA = (sigA | 0x0400)<<4;
-    sigB = (sigB | 0x0400)<<5;
-    sig32Z = (uint_fast32_t) sigA * sigB;
-    sigZ = sig32Z>>16;
-    if ( sig32Z & 0xFFFF ) sigZ |= 1;
-    if ( sigZ < 0x4000 ) {
-        --expZ;
-        sigZ <<= 1;
-    }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infArg:
-    if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ = defaultNaNF16UI;
-    } else {
-        uiZ = packToF16UI( signZ, 0x1F, 0 );
-    }
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF16UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f16_mul( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    bool signB;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    bool signZ;
+    uint_fast16_t magBits;
+    struct exp8_sig16 normExpSig;
+    int_fast8_t expZ;
+    uint_fast32_t sig32Z;
+    uint_fast16_t sigZ, uiZ;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF16UI( uiB );
+    expB  = expF16UI( uiB );
+    sigB  = fracF16UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
+        magBits = expB | sigB;
+        goto infArg;
+    }
+    if ( expB == 0x1F ) {
+        if ( sigB ) goto propagateNaN;
+        magBits = expA | sigA;
+        goto infArg;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zero;
+        normExpSig = softfloat_normSubnormalF16Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0xF;
+    sigA = (sigA | 0x0400)<<4;
+    sigB = (sigB | 0x0400)<<5;
+    sig32Z = (uint_fast32_t) sigA * sigB;
+    sigZ = sig32Z>>16;
+    if ( sig32Z & 0xFFFF ) sigZ |= 1;
+    if ( sigZ < 0x4000 ) {
+        --expZ;
+        sigZ <<= 1;
+    }
+    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infArg:
+    if ( ! magBits ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ = defaultNaNF16UI;
+    } else {
+        uiZ = packToF16UI( signZ, 0x1F, 0 );
+    }
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF16UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_mulAdd.c b/softfloat/source/f16_mulAdd.c
index e97571a..0929372 100644
--- a/softfloat/source/f16_mulAdd.c
+++ b/softfloat/source/f16_mulAdd.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    union ui16_f16 uC;
-    uint_fast16_t uiC;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    uC.f = c;
-    uiC = uC.ui;
-    return softfloat_mulAddF16( uiA, uiB, uiC, 0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t f16_mulAdd( float16_t a, float16_t b, float16_t c )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    union ui16_f16 uC;
+    uint_fast16_t uiC;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    uC.f = c;
+    uiC = uC.ui;
+    return softfloat_mulAddF16( uiA, uiB, uiC, 0 );
+
+}
+
diff --git a/softfloat/source/f16_rem.c b/softfloat/source/f16_rem.c
index 0ffa498..76a0de6 100644
--- a/softfloat/source/f16_rem.c
+++ b/softfloat/source/f16_rem.c
@@ -1,171 +1,171 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f16_rem( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool signA;
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    struct exp8_sig16 normExpSig;
-    uint16_t rem;
-    int_fast8_t expDiff;
-    uint_fast16_t q;
-    uint32_t recip32, q32;
-    uint16_t altRem, meanRem;
-    bool signRem;
-    uint_fast16_t uiZ;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF16UI( uiA );
-    expA  = expF16UI( uiA );
-    sigA  = fracF16UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    expB = expF16UI( uiB );
-    sigB = fracF16UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x1F ) {
-        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
-        goto invalid;
-    }
-    if ( expB == 0x1F ) {
-        if ( sigB ) goto propagateNaN;
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalF16Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF16Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    rem = sigA | 0x0400;
-    sigB |= 0x0400;
-    expDiff = expA - expB;
-    if ( expDiff < 1 ) {
-        if ( expDiff < -1 ) return a;
-        sigB <<= 3;
-        if ( expDiff ) {
-            rem <<= 2;
-            q = 0;
-        } else {
-            rem <<= 3;
-            q = (sigB <= rem);
-            if ( q ) rem -= sigB;
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( (uint_fast32_t) sigB<<21 );
-        /*--------------------------------------------------------------------
-        | Changing the shift of `rem' here requires also changing the initial
-        | subtraction from `expDiff'.
-        *--------------------------------------------------------------------*/
-        rem <<= 4;
-        expDiff -= 31;
-        /*--------------------------------------------------------------------
-        | The scale of `sigB' affects how many bits are obtained during each
-        | cycle of the loop.  Currently this is 29 bits per loop iteration,
-        | which is believed to be the maximum possible.
-        *--------------------------------------------------------------------*/
-        sigB <<= 3;
-        for (;;) {
-            q32 = (rem * (uint_fast64_t) recip32)>>16;
-            if ( expDiff < 0 ) break;
-            rem = -((uint_fast16_t) q32 * sigB);
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -30 here.)
-        *--------------------------------------------------------------------*/
-        q32 >>= ~expDiff & 31;
-        q = q32;
-        rem = (rem<<(expDiff + 30)) - q * sigB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    do {
-        altRem = rem;
-        ++q;
-        rem -= sigB;
-    } while ( ! (rem & 0x8000) );
-    meanRem = rem + altRem;
-    if ( (meanRem & 0x8000) || (! meanRem && (q & 1)) ) rem = altRem;
-    signRem = signA;
-    if ( 0x8000 <= rem ) {
-        signRem = ! signRem;
-        rem = -rem;
-    }
-    return softfloat_normRoundPackToF16( signRem, expB, rem );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF16UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f16_rem( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    struct exp8_sig16 normExpSig;
+    uint16_t rem;
+    int_fast8_t expDiff;
+    uint_fast16_t q;
+    uint32_t recip32, q32;
+    uint16_t altRem, meanRem;
+    bool signRem;
+    uint_fast16_t uiZ;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    expB = expF16UI( uiB );
+    sigB = fracF16UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN;
+        goto invalid;
+    }
+    if ( expB == 0x1F ) {
+        if ( sigB ) goto propagateNaN;
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) goto invalid;
+        normExpSig = softfloat_normSubnormalF16Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    rem = sigA | 0x0400;
+    sigB |= 0x0400;
+    expDiff = expA - expB;
+    if ( expDiff < 1 ) {
+        if ( expDiff < -1 ) return a;
+        sigB <<= 3;
+        if ( expDiff ) {
+            rem <<= 2;
+            q = 0;
+        } else {
+            rem <<= 3;
+            q = (sigB <= rem);
+            if ( q ) rem -= sigB;
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( (uint_fast32_t) sigB<<21 );
+        /*--------------------------------------------------------------------
+        | Changing the shift of `rem' here requires also changing the initial
+        | subtraction from `expDiff'.
+        *--------------------------------------------------------------------*/
+        rem <<= 4;
+        expDiff -= 31;
+        /*--------------------------------------------------------------------
+        | The scale of `sigB' affects how many bits are obtained during each
+        | cycle of the loop.  Currently this is 29 bits per loop iteration,
+        | which is believed to be the maximum possible.
+        *--------------------------------------------------------------------*/
+        sigB <<= 3;
+        for (;;) {
+            q32 = (rem * (uint_fast64_t) recip32)>>16;
+            if ( expDiff < 0 ) break;
+            rem = -((uint_fast16_t) q32 * sigB);
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -30 here.)
+        *--------------------------------------------------------------------*/
+        q32 >>= ~expDiff & 31;
+        q = q32;
+        rem = (rem<<(expDiff + 30)) - q * sigB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    do {
+        altRem = rem;
+        ++q;
+        rem -= sigB;
+    } while ( ! (rem & 0x8000) );
+    meanRem = rem + altRem;
+    if ( (meanRem & 0x8000) || (! meanRem && (q & 1)) ) rem = altRem;
+    signRem = signA;
+    if ( 0x8000 <= rem ) {
+        signRem = ! signRem;
+        rem = -rem;
+    }
+    return softfloat_normRoundPackToF16( signRem, expB, rem );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF16UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_roundToInt.c b/softfloat/source/f16_roundToInt.c
index a567d51..d5ed190 100644
--- a/softfloat/source/f16_roundToInt.c
+++ b/softfloat/source/f16_roundToInt.c
@@ -1,120 +1,120 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    int_fast8_t exp;
-    uint_fast16_t uiZ, lastBitMask, roundBitsMask;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp <= 0xE ) {
-        if ( !(uint16_t) (uiA<<1) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        uiZ = uiA & packToF16UI( 1, 0, 0 );
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !fracF16UI( uiA ) ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0xE ) uiZ |= packToF16UI( 0, 0xF, 0 );
-            break;
-         case softfloat_round_min:
-            if ( uiZ ) uiZ = packToF16UI( 1, 0xF, 0 );
-            break;
-         case softfloat_round_max:
-            if ( !uiZ ) uiZ = packToF16UI( 0, 0xF, 0 );
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            uiZ |= packToF16UI( 0, 0xF, 0 );
-            break;
-#endif
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x19 <= exp ) {
-        if ( (exp == 0x1F) && fracF16UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
-            goto uiZ;
-        }
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = uiA;
-    lastBitMask = (uint_fast16_t) 1<<(0x19 - exp);
-    roundBitsMask = lastBitMask - 1;
-    if ( roundingMode == softfloat_round_near_maxMag ) {
-        uiZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_near_even ) {
-        uiZ += lastBitMask>>1;
-        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
-    } else if (
-        roundingMode
-            == (signF16UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
-    ) {
-        uiZ += roundBitsMask;
-    }
-    uiZ &= ~roundBitsMask;
-    if ( uiZ != uiA ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f16_roundToInt( float16_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    int_fast8_t exp;
+    uint_fast16_t uiZ, lastBitMask, roundBitsMask;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp <= 0xE ) {
+        if ( !(uint16_t) (uiA<<1) ) return a;
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        uiZ = uiA & packToF16UI( 1, 0, 0 );
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !fracF16UI( uiA ) ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0xE ) uiZ |= packToF16UI( 0, 0xF, 0 );
+            break;
+         case softfloat_round_min:
+            if ( uiZ ) uiZ = packToF16UI( 1, 0xF, 0 );
+            break;
+         case softfloat_round_max:
+            if ( !uiZ ) uiZ = packToF16UI( 0, 0xF, 0 );
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            uiZ |= packToF16UI( 0, 0xF, 0 );
+            break;
+#endif
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x19 <= exp ) {
+        if ( (exp == 0x1F) && fracF16UI( uiA ) ) {
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            goto uiZ;
+        }
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = uiA;
+    lastBitMask = (uint_fast16_t) 1<<(0x19 - exp);
+    roundBitsMask = lastBitMask - 1;
+    if ( roundingMode == softfloat_round_near_maxMag ) {
+        uiZ += lastBitMask>>1;
+    } else if ( roundingMode == softfloat_round_near_even ) {
+        uiZ += lastBitMask>>1;
+        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
+    } else if (
+        roundingMode
+            == (signF16UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
+    ) {
+        uiZ += roundBitsMask;
+    }
+    uiZ &= ~roundBitsMask;
+    if ( uiZ != uiA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_sqrt.c b/softfloat/source/f16_sqrt.c
index 47a3bbf..40865fc 100644
--- a/softfloat/source/f16_sqrt.c
+++ b/softfloat/source/f16_sqrt.c
@@ -1,136 +1,136 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
-extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
-
-float16_t f16_sqrt( float16_t a )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool signA;
-    int_fast8_t expA;
-    uint_fast16_t sigA, uiZ;
-    struct exp8_sig16 normExpSig;
-    int_fast8_t expZ;
-    int index;
-    uint_fast16_t r0;
-    uint_fast32_t ESqrR0;
-    uint16_t sigma0;
-    uint_fast16_t recipSqrt16, sigZ, shiftedSigZ;
-    uint16_t negRem;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF16UI( uiA );
-    expA  = expF16UI( uiA );
-    sigA  = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x1F ) {
-        if ( sigA ) {
-            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
-            goto uiZ;
-        }
-        if ( ! signA ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signA ) {
-        if ( ! (expA | sigA) ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF16Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0xF)>>1) + 0xE;
-    expA &= 1;
-    sigA |= 0x0400;
-    index = (sigA>>6 & 0xE) + expA;
-    r0 = softfloat_approxRecipSqrt_1k0s[index]
-             - (((uint_fast32_t) softfloat_approxRecipSqrt_1k1s[index]
-                     * (sigA & 0x7F))
-                    >>11);
-    ESqrR0 = ((uint_fast32_t) r0 * r0)>>1;
-    if ( expA ) ESqrR0 >>= 1;
-    sigma0 = ~(uint_fast16_t) ((ESqrR0 * sigA)>>16);
-    recipSqrt16 = r0 + (((uint_fast32_t) r0 * sigma0)>>25);
-    if ( ! (recipSqrt16 & 0x8000) ) recipSqrt16 = 0x8000;
-    sigZ = ((uint_fast32_t) (sigA<<5) * recipSqrt16)>>16;
-    if ( expA ) sigZ >>= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    ++sigZ;
-    if ( ! (sigZ & 7) ) {
-        shiftedSigZ = sigZ>>1;
-        negRem = shiftedSigZ * shiftedSigZ;
-        sigZ &= ~1;
-        if ( negRem & 0x8000 ) {
-            sigZ |= 1;
-        } else {
-            if ( negRem ) --sigZ;
-        }
-    }
-    return softfloat_roundPackToF16( 0, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF16UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
+extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
+
+float16_t f16_sqrt( float16_t a )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA, uiZ;
+    struct exp8_sig16 normExpSig;
+    int_fast8_t expZ;
+    int index;
+    uint_fast16_t r0;
+    uint_fast32_t ESqrR0;
+    uint16_t sigma0;
+    uint_fast16_t recipSqrt16, sigZ, shiftedSigZ;
+    uint16_t negRem;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA ) {
+            uiZ = softfloat_propagateNaNF16UI( uiA, 0 );
+            goto uiZ;
+        }
+        if ( ! signA ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signA ) {
+        if ( ! (expA | sigA) ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0xF)>>1) + 0xE;
+    expA &= 1;
+    sigA |= 0x0400;
+    index = (sigA>>6 & 0xE) + expA;
+    r0 = softfloat_approxRecipSqrt_1k0s[index]
+             - (((uint_fast32_t) softfloat_approxRecipSqrt_1k1s[index]
+                     * (sigA & 0x7F))
+                    >>11);
+    ESqrR0 = ((uint_fast32_t) r0 * r0)>>1;
+    if ( expA ) ESqrR0 >>= 1;
+    sigma0 = ~(uint_fast16_t) ((ESqrR0 * sigA)>>16);
+    recipSqrt16 = r0 + (((uint_fast32_t) r0 * sigma0)>>25);
+    if ( ! (recipSqrt16 & 0x8000) ) recipSqrt16 = 0x8000;
+    sigZ = ((uint_fast32_t) (sigA<<5) * recipSqrt16)>>16;
+    if ( expA ) sigZ >>= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    ++sigZ;
+    if ( ! (sigZ & 7) ) {
+        shiftedSigZ = sigZ>>1;
+        negRem = shiftedSigZ * shiftedSigZ;
+        sigZ &= ~1;
+        if ( negRem & 0x8000 ) {
+            sigZ |= 1;
+        } else {
+            if ( negRem ) --sigZ;
+        }
+    }
+    return softfloat_roundPackToF16( 0, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF16UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_sub.c b/softfloat/source/f16_sub.c
index 03a87cf..e18f25c 100644
--- a/softfloat/source/f16_sub.c
+++ b/softfloat/source/f16_sub.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t f16_sub( float16_t a, float16_t b )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    union ui16_f16 uB;
-    uint_fast16_t uiB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
-    if ( signF16UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF16( uiA, uiB );
-    } else {
-        return softfloat_subMagsF16( uiA, uiB );
-    }
-#else
-    magsFuncPtr =
-        signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;
-    return (*magsFuncPtr)( uiA, uiB );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t f16_sub( float16_t a, float16_t b )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    union ui16_f16 uB;
+    uint_fast16_t uiB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
+    float16_t (*magsFuncPtr)( uint_fast16_t, uint_fast16_t );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
+    if ( signF16UI( uiA ^ uiB ) ) {
+        return softfloat_addMagsF16( uiA, uiB );
+    } else {
+        return softfloat_subMagsF16( uiA, uiB );
+    }
+#else
+    magsFuncPtr =
+        signF16UI( uiA ^ uiB ) ? softfloat_addMagsF16 : softfloat_subMagsF16;
+    return (*magsFuncPtr)( uiA, uiB );
+#endif
+
+}
+
diff --git a/softfloat/source/f16_to_extF80.c b/softfloat/source/f16_to_extF80.c
index 99c2dfc..aaeed4d 100644
--- a/softfloat/source/f16_to_extF80.c
+++ b/softfloat/source/f16_to_extF80.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t f16_to_extF80( float16_t a )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    struct exp8_sig16 normExpSig;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
-            uiZ64 = uiZ.v64;
-            uiZ0  = uiZ.v0;
-        } else {
-            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-            uiZ0  = UINT64_C( 0x8000000000000000 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );
-    uiZ0  = (uint_fast64_t) (frac | 0x0400)<<53;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t f16_to_extF80( float16_t a )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    struct exp8_sig16 normExpSig;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
+            uiZ64 = uiZ.v64;
+            uiZ0  = uiZ.v0;
+        } else {
+            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+            uiZ0  = UINT64_C( 0x8000000000000000 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );
+    uiZ0  = (uint_fast64_t) (frac | 0x0400)<<53;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_to_extF80M.c b/softfloat/source/f16_to_extF80M.c
index 7f2d534..75c5e60 100644
--- a/softfloat/source/f16_to_extF80M.c
+++ b/softfloat/source/f16_to_extF80M.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = f16_to_extF80( a );
-
-}
-
-#else
-
-void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    union ui16_f16 uA;
-    uint16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint16_t frac;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ64;
-    uint32_t uiZ32;
-    struct exp8_sig16 normExpSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zSPtr = (struct extFloat80M *) zPtr;
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
-            return;
-        }
-        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-        uiZ32 = 0x80000000;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ32 = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );
-    uiZ32 = 0x80000000 | (uint32_t) frac<<21;
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = (uint64_t) uiZ32<<32;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = f16_to_extF80( a );
+
+}
+
+#else
+
+void f16_to_extF80M( float16_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    union ui16_f16 uA;
+    uint16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint16_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ64;
+    uint32_t uiZ32;
+    struct exp8_sig16 normExpSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zSPtr = (struct extFloat80M *) zPtr;
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
+            return;
+        }
+        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+        uiZ32 = 0x80000000;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ32 = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3FF0 );
+    uiZ32 = 0x80000000 | (uint32_t) frac<<21;
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = (uint64_t) uiZ32<<32;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f16_to_f128.c b/softfloat/source/f16_to_f128.c
index c4b81dc..107479a 100644
--- a/softfloat/source/f16_to_f128.c
+++ b/softfloat/source/f16_to_f128.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f16_to_f128( float16_t a )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    struct exp8_sig16 normExpSig;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
-        } else {
-            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
-            uiZ.v0  = 0;
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ.v64 = packToF128UI64( sign, 0, 0 );
-            uiZ.v0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ.v64 = packToF128UI64( sign, exp + 0x3FF0, (uint_fast64_t) frac<<38 );
-    uiZ.v0  = 0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f16_to_f128( float16_t a )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    struct exp8_sig16 normExpSig;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
+        } else {
+            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
+            uiZ.v0  = 0;
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ.v64 = packToF128UI64( sign, 0, 0 );
+            uiZ.v0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ.v64 = packToF128UI64( sign, exp + 0x3FF0, (uint_fast64_t) frac<<38 );
+    uiZ.v0  = 0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_to_f128M.c b/softfloat/source/f16_to_f128M.c
index b4fc873..a31dab6 100644
--- a/softfloat/source/f16_to_f128M.c
+++ b/softfloat/source/f16_to_f128M.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f16_to_f128M( float16_t a, float128_t *zPtr )
-{
-
-    *zPtr = f16_to_f128( a );
-
-}
-
-#else
-
-void f16_to_f128M( float16_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr;
-    union ui16_f16 uA;
-    uint16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint16_t frac;
-    struct commonNaN commonNaN;
-    uint32_t uiZ96;
-    struct exp8_sig16 normExpSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
-            return;
-        }
-        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ96 = packToF128UI96( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ96 = packToF128UI96( sign, exp + 0x3FF0, (uint32_t) frac<<6 );
- uiZ:
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f16_to_f128M( float16_t a, float128_t *zPtr )
+{
+
+    *zPtr = f16_to_f128( a );
+
+}
+
+#else
+
+void f16_to_f128M( float16_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr;
+    union ui16_f16 uA;
+    uint16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint16_t frac;
+    struct commonNaN commonNaN;
+    uint32_t uiZ96;
+    struct exp8_sig16 normExpSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
+            return;
+        }
+        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ96 = packToF128UI96( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ96 = packToF128UI96( sign, exp + 0x3FF0, (uint32_t) frac<<6 );
+ uiZ:
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f16_to_f32.c b/softfloat/source/f16_to_f32.c
index a219454..c58208a 100644
--- a/softfloat/source/f16_to_f32.c
+++ b/softfloat/source/f16_to_f32.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f16_to_f32( float16_t a )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    struct commonNaN commonNaN;
-    uint_fast32_t uiZ;
-    struct exp8_sig16 normExpSig;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ = packToF32UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = packToF32UI( sign, exp + 0x70, (uint_fast32_t) frac<<13 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f16_to_f32( float16_t a )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    struct commonNaN commonNaN;
+    uint_fast32_t uiZ;
+    struct exp8_sig16 normExpSig;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ = packToF32UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = packToF32UI( sign, exp + 0x70, (uint_fast32_t) frac<<13 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_to_f64.c b/softfloat/source/f16_to_f64.c
index 7e87c25..dd85d33 100644
--- a/softfloat/source/f16_to_f64.c
+++ b/softfloat/source/f16_to_f64.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f16_to_f64( float16_t a )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    struct commonNaN commonNaN;
-    uint_fast64_t uiZ;
-    struct exp8_sig16 normExpSig;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        if ( frac ) {
-            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ = packToF64UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = packToF64UI( sign, exp + 0x3F0, (uint_fast64_t) frac<<42 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f16_to_f64( float16_t a )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    struct commonNaN commonNaN;
+    uint_fast64_t uiZ;
+    struct exp8_sig16 normExpSig;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        if ( frac ) {
+            softfloat_f16UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ = packToF64UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = packToF64UI( sign, exp + 0x3F0, (uint_fast64_t) frac<<42 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f16_to_i32.c b/softfloat/source/f16_to_i32.c
index 805c4e5..aeb2fac 100644
--- a/softfloat/source/f16_to_i32.c
+++ b/softfloat/source/f16_to_i32.c
@@ -1,87 +1,87 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast32_t sig32;
-    int_fast8_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            frac ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = frac;
-    if ( exp ) {
-        sig32 |= 0x0400;
-        shiftDist = exp - 0x19;
-        if ( 0 <= shiftDist ) {
-            sig32 <<= shiftDist;
-            return sign ? -sig32 : sig32;
-        }
-        shiftDist = exp - 0x0D;
-        if ( 0 < shiftDist ) sig32 <<= shiftDist;
-    }
-    return
-        softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f16_to_i32( float16_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast32_t sig32;
+    int_fast8_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            frac ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = frac;
+    if ( exp ) {
+        sig32 |= 0x0400;
+        shiftDist = exp - 0x19;
+        if ( 0 <= shiftDist ) {
+            sig32 <<= shiftDist;
+            return sign ? -sig32 : sig32;
+        }
+        shiftDist = exp - 0x0D;
+        if ( 0 < shiftDist ) sig32 <<= shiftDist;
+    }
+    return
+        softfloat_roundToI32(
+            sign, (uint_fast32_t) sig32, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f16_to_i32_r_minMag.c b/softfloat/source/f16_to_i32_r_minMag.c
index b1f9963..1aa72f5 100644
--- a/softfloat/source/f16_to_i32_r_minMag.c
+++ b/softfloat/source/f16_to_i32_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast8_t shiftDist;
-    bool sign;
-    int_fast32_t alignedSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = exp - 0x0F;
-    if ( shiftDist < 0 ) {
-        if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF16UI( uiA );
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x1F) && frac ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
-    if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    alignedSig >>= 10;
-    return sign ? -alignedSig : alignedSig;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f16_to_i32_r_minMag( float16_t a, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast8_t shiftDist;
+    bool sign;
+    int_fast32_t alignedSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = exp - 0x0F;
+    if ( shiftDist < 0 ) {
+        if ( exact && (exp | frac) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF16UI( uiA );
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x1F) && frac ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
+    if ( exact && (alignedSig & 0x3FF) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    alignedSig >>= 10;
+    return sign ? -alignedSig : alignedSig;
+
+}
+
diff --git a/softfloat/source/f16_to_i64.c b/softfloat/source/f16_to_i64.c
index e3c0065..c0487cf 100644
--- a/softfloat/source/f16_to_i64.c
+++ b/softfloat/source/f16_to_i64.c
@@ -1,87 +1,87 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast32_t sig32;
-    int_fast8_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            frac ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = frac;
-    if ( exp ) {
-        sig32 |= 0x0400;
-        shiftDist = exp - 0x19;
-        if ( 0 <= shiftDist ) {
-            sig32 <<= shiftDist;
-            return sign ? -sig32 : sig32;
-        }
-        shiftDist = exp - 0x0D;
-        if ( 0 < shiftDist ) sig32 <<= shiftDist;
-    }
-    return
-        softfloat_roundToI32(
-            sign, (uint_fast32_t) sig32, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f16_to_i64( float16_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast32_t sig32;
+    int_fast8_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            frac ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = frac;
+    if ( exp ) {
+        sig32 |= 0x0400;
+        shiftDist = exp - 0x19;
+        if ( 0 <= shiftDist ) {
+            sig32 <<= shiftDist;
+            return sign ? -sig32 : sig32;
+        }
+        shiftDist = exp - 0x0D;
+        if ( 0 < shiftDist ) sig32 <<= shiftDist;
+    }
+    return
+        softfloat_roundToI32(
+            sign, (uint_fast32_t) sig32, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f16_to_i64_r_minMag.c b/softfloat/source/f16_to_i64_r_minMag.c
index a5a6a07..25f91e2 100644
--- a/softfloat/source/f16_to_i64_r_minMag.c
+++ b/softfloat/source/f16_to_i64_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast8_t shiftDist;
-    bool sign;
-    int_fast32_t alignedSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = exp - 0x0F;
-    if ( shiftDist < 0 ) {
-        if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF16UI( uiA );
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x1F) && frac ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
-    if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    alignedSig >>= 10;
-    return sign ? -alignedSig : alignedSig;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f16_to_i64_r_minMag( float16_t a, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast8_t shiftDist;
+    bool sign;
+    int_fast32_t alignedSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = exp - 0x0F;
+    if ( shiftDist < 0 ) {
+        if ( exact && (exp | frac) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF16UI( uiA );
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x1F) && frac ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    alignedSig = (int_fast32_t) (frac | 0x0400)<<shiftDist;
+    if ( exact && (alignedSig & 0x3FF) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    alignedSig >>= 10;
+    return sign ? -alignedSig : alignedSig;
+
+}
+
diff --git a/softfloat/source/f16_to_ui32.c b/softfloat/source/f16_to_ui32.c
index 5371ca3..19ab66e 100644
--- a/softfloat/source/f16_to_ui32.c
+++ b/softfloat/source/f16_to_ui32.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    uint_fast32_t sig32;
-    int_fast8_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            frac ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = frac;
-    if ( exp ) {
-        sig32 |= 0x0400;
-        shiftDist = exp - 0x19;
-        if ( (0 <= shiftDist) && ! sign ) {
-            return sig32<<shiftDist;
-        }
-        shiftDist = exp - 0x0D;
-        if ( 0 < shiftDist ) sig32 <<= shiftDist;
-    }
-    return softfloat_roundToUI32( sign, sig32, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f16_to_ui32( float16_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    uint_fast32_t sig32;
+    int_fast8_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            frac ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = frac;
+    if ( exp ) {
+        sig32 |= 0x0400;
+        shiftDist = exp - 0x19;
+        if ( (0 <= shiftDist) && ! sign ) {
+            return sig32<<shiftDist;
+        }
+        shiftDist = exp - 0x0D;
+        if ( 0 < shiftDist ) sig32 <<= shiftDist;
+    }
+    return softfloat_roundToUI32( sign, sig32, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f16_to_ui32_r_minMag.c b/softfloat/source/f16_to_ui32_r_minMag.c
index 5d51df5..a21d41a 100644
--- a/softfloat/source/f16_to_ui32_r_minMag.c
+++ b/softfloat/source/f16_to_ui32_r_minMag.c
@@ -1,87 +1,87 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast8_t shiftDist;
-    bool sign;
-    uint_fast32_t alignedSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = exp - 0x0F;
-    if ( shiftDist < 0 ) {
-        if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF16UI( uiA );
-    if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x1F) && frac ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
-    if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return alignedSig>>10;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f16_to_ui32_r_minMag( float16_t a, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast8_t shiftDist;
+    bool sign;
+    uint_fast32_t alignedSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = exp - 0x0F;
+    if ( shiftDist < 0 ) {
+        if ( exact && (exp | frac) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF16UI( uiA );
+    if ( sign || (exp == 0x1F) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x1F) && frac ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
+    if ( exact && (alignedSig & 0x3FF) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return alignedSig>>10;
+
+}
+
diff --git a/softfloat/source/f16_to_ui64.c b/softfloat/source/f16_to_ui64.c
index e6cb000..4260b7a 100644
--- a/softfloat/source/f16_to_ui64.c
+++ b/softfloat/source/f16_to_ui64.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    bool sign;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    uint_fast32_t sig32;
-    int_fast8_t shiftDist;
-#ifndef SOFTFLOAT_FAST_INT64
-    uint32_t extSig[3];
-#endif
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF16UI( uiA );
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x1F ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            frac ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig32 = frac;
-    if ( exp ) {
-        sig32 |= 0x0400;
-        shiftDist = exp - 0x19;
-        if ( (0 <= shiftDist) && ! sign ) {
-            return sig32<<shiftDist;
-        }
-        shiftDist = exp - 0x0D;
-        if ( 0 < shiftDist ) sig32 <<= shiftDist;
-    }
-#ifdef SOFTFLOAT_FAST_INT64
-    return
-        softfloat_roundToUI64(
-            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
-#else
-    extSig[indexWord( 3, 2 )] = 0;
-    extSig[indexWord( 3, 1 )] = sig32>>12;
-    extSig[indexWord( 3, 0 )] = sig32<<20;
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f16_to_ui64( float16_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    bool sign;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    uint_fast32_t sig32;
+    int_fast8_t shiftDist;
+#ifndef SOFTFLOAT_FAST_INT64
+    uint32_t extSig[3];
+#endif
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF16UI( uiA );
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x1F ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            frac ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig32 = frac;
+    if ( exp ) {
+        sig32 |= 0x0400;
+        shiftDist = exp - 0x19;
+        if ( (0 <= shiftDist) && ! sign ) {
+            return sig32<<shiftDist;
+        }
+        shiftDist = exp - 0x0D;
+        if ( 0 < shiftDist ) sig32 <<= shiftDist;
+    }
+#ifdef SOFTFLOAT_FAST_INT64
+    return
+        softfloat_roundToUI64(
+            sign, sig32>>12, (uint_fast64_t) sig32<<52, roundingMode, exact );
+#else
+    extSig[indexWord( 3, 2 )] = 0;
+    extSig[indexWord( 3, 1 )] = sig32>>12;
+    extSig[indexWord( 3, 0 )] = sig32<<20;
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+#endif
+
+}
+
diff --git a/softfloat/source/f16_to_ui64_r_minMag.c b/softfloat/source/f16_to_ui64_r_minMag.c
index b4f975f..098a597 100644
--- a/softfloat/source/f16_to_ui64_r_minMag.c
+++ b/softfloat/source/f16_to_ui64_r_minMag.c
@@ -1,87 +1,87 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
-{
-    union ui16_f16 uA;
-    uint_fast16_t uiA;
-    int_fast8_t exp;
-    uint_fast16_t frac;
-    int_fast8_t shiftDist;
-    bool sign;
-    uint_fast32_t alignedSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp  = expF16UI( uiA );
-    frac = fracF16UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = exp - 0x0F;
-    if ( shiftDist < 0 ) {
-        if ( exact && (exp | frac) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF16UI( uiA );
-    if ( sign || (exp == 0x1F) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x1F) && frac ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
-    if ( exact && (alignedSig & 0x3FF) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return alignedSig>>10;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f16_to_ui64_r_minMag( float16_t a, bool exact )
+{
+    union ui16_f16 uA;
+    uint_fast16_t uiA;
+    int_fast8_t exp;
+    uint_fast16_t frac;
+    int_fast8_t shiftDist;
+    bool sign;
+    uint_fast32_t alignedSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp  = expF16UI( uiA );
+    frac = fracF16UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = exp - 0x0F;
+    if ( shiftDist < 0 ) {
+        if ( exact && (exp | frac) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF16UI( uiA );
+    if ( sign || (exp == 0x1F) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x1F) && frac ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    alignedSig = (uint_fast32_t) (frac | 0x0400)<<shiftDist;
+    if ( exact && (alignedSig & 0x3FF) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return alignedSig>>10;
+
+}
+
diff --git a/softfloat/source/f32_add.c b/softfloat/source/f32_add.c
index 70e03e7..f59ac0a 100644
--- a/softfloat/source/f32_add.c
+++ b/softfloat/source/f32_add.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t f32_add( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
-    if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_subMagsF32( uiA, uiB );
-    } else {
-        return softfloat_addMagsF32( uiA, uiB );
-    }
-#else
-    magsFuncPtr =
-        signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t f32_add( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
+    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
+    if ( signF32UI( uiA ^ uiB ) ) {
+        return softfloat_subMagsF32( uiA, uiB );
+    } else {
+        return softfloat_addMagsF32( uiA, uiB );
+    }
+#else
+    magsFuncPtr =
+        signF32UI( uiA ^ uiB ) ? softfloat_subMagsF32 : softfloat_addMagsF32;
+    return (*magsFuncPtr)( uiA, uiB );
+#endif
+
+}
+
diff --git a/softfloat/source/f32_div.c b/softfloat/source/f32_div.c
index 05ec701..8d44479 100644
--- a/softfloat/source/f32_div.c
+++ b/softfloat/source/f32_div.c
@@ -1,180 +1,180 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_div( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    bool signZ;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expZ;
-#ifdef SOFTFLOAT_FAST_DIV64TO32
-    uint_fast64_t sig64A;
-    uint_fast32_t sigZ;
-#else
-    uint_fast32_t sigZ;
-    uint_fast64_t rem;
-#endif
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA  = expF32UI( uiA );
-    sigA  = fracF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF32UI( uiB );
-    expB  = expF32UI( uiB );
-    sigB  = fracF32UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0xFF ) {
-        if ( sigA ) goto propagateNaN;
-        if ( expB == 0xFF ) {
-            if ( sigB ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) {
-            if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x7E;
-    sigA |= 0x00800000;
-    sigB |= 0x00800000;
-#ifdef SOFTFLOAT_FAST_DIV64TO32
-    if ( sigA < sigB ) {
-        --expZ;
-        sig64A = (uint_fast64_t) sigA<<31;
-    } else {
-        sig64A = (uint_fast64_t) sigA<<30;
-    }
-    sigZ = sig64A / sigB;
-    if ( ! (sigZ & 0x3F) ) sigZ |= ((uint_fast64_t) sigB * sigZ != sig64A);
-#else
-    if ( sigA < sigB ) {
-        --expZ;
-        sigA <<= 8;
-    } else {
-        sigA <<= 7;
-    }
-    sigB <<= 8;
-    sigZ = ((uint_fast64_t) sigA * softfloat_approxRecip32_1( sigB ))>>32;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigZ += 2;
-    if ( (sigZ & 0x3F) < 2 ) {
-        sigZ &= ~3;
-#ifdef SOFTFLOAT_FAST_INT64
-        rem = ((uint_fast64_t) sigA<<31) - (uint_fast64_t) sigZ * sigB;
-#else
-        rem = ((uint_fast64_t) sigA<<32) - (uint_fast64_t) (sigZ<<1) * sigB;
-#endif
-        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
-            sigZ -= 4;
-        } else {
-            if ( rem ) sigZ |= 1;
-        }
-    }
-#endif
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ = packToF32UI( signZ, 0xFF, 0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF32UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f32_div( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    bool signZ;
+    struct exp16_sig32 normExpSig;
+    int_fast16_t expZ;
+#ifdef SOFTFLOAT_FAST_DIV64TO32
+    uint_fast64_t sig64A;
+    uint_fast32_t sigZ;
+#else
+    uint_fast32_t sigZ;
+    uint_fast64_t rem;
+#endif
+    uint_fast32_t uiZ;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF32UI( uiA );
+    expA  = expF32UI( uiA );
+    sigA  = fracF32UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF32UI( uiB );
+    expB  = expF32UI( uiB );
+    sigB  = fracF32UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0xFF ) {
+        if ( sigA ) goto propagateNaN;
+        if ( expB == 0xFF ) {
+            if ( sigB ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0xFF ) {
+        if ( sigB ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) {
+            if ( ! (expA | sigA) ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF32Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x7E;
+    sigA |= 0x00800000;
+    sigB |= 0x00800000;
+#ifdef SOFTFLOAT_FAST_DIV64TO32
+    if ( sigA < sigB ) {
+        --expZ;
+        sig64A = (uint_fast64_t) sigA<<31;
+    } else {
+        sig64A = (uint_fast64_t) sigA<<30;
+    }
+    sigZ = sig64A / sigB;
+    if ( ! (sigZ & 0x3F) ) sigZ |= ((uint_fast64_t) sigB * sigZ != sig64A);
+#else
+    if ( sigA < sigB ) {
+        --expZ;
+        sigA <<= 8;
+    } else {
+        sigA <<= 7;
+    }
+    sigB <<= 8;
+    sigZ = ((uint_fast64_t) sigA * softfloat_approxRecip32_1( sigB ))>>32;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigZ += 2;
+    if ( (sigZ & 0x3F) < 2 ) {
+        sigZ &= ~3;
+#ifdef SOFTFLOAT_FAST_INT64
+        rem = ((uint_fast64_t) sigA<<31) - (uint_fast64_t) sigZ * sigB;
+#else
+        rem = ((uint_fast64_t) sigA<<32) - (uint_fast64_t) (sigZ<<1) * sigB;
+#endif
+        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
+            sigZ -= 4;
+        } else {
+            if ( rem ) sigZ |= 1;
+        }
+    }
+#endif
+    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF32UI;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ = packToF32UI( signZ, 0xFF, 0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF32UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_eq.c b/softfloat/source/f32_eq.c
index 801bbfd..316fe6a 100644
--- a/softfloat/source/f32_eq.c
+++ b/softfloat/source/f32_eq.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_eq( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f32_eq( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1);
+
+}
+
diff --git a/softfloat/source/f32_eq_signaling.c b/softfloat/source/f32_eq_signaling.c
index 4c610ff..03395f3 100644
--- a/softfloat/source/f32_eq_signaling.c
+++ b/softfloat/source/f32_eq_signaling.c
@@ -1,61 +1,61 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_eq_signaling( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f32_eq_signaling( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    return (uiA == uiB) || ! (uint32_t) ((uiA | uiB)<<1);
+
+}
+
diff --git a/softfloat/source/f32_isSignalingNaN.c b/softfloat/source/f32_isSignalingNaN.c
index f5954cb..d98cc9b 100644
--- a/softfloat/source/f32_isSignalingNaN.c
+++ b/softfloat/source/f32_isSignalingNaN.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_isSignalingNaN( float32_t a )
-{
-    union ui32_f32 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF32UI( uA.ui );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f32_isSignalingNaN( float32_t a )
+{
+    union ui32_f32 uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNF32UI( uA.ui );
+
+}
+
diff --git a/softfloat/source/f32_le.c b/softfloat/source/f32_le.c
index d89d1e8..83a3007 100644
--- a/softfloat/source/f32_le.c
+++ b/softfloat/source/f32_le.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_le( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f32_le( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF32UI( uiA );
+    signB = signF32UI( uiB );
+    return
+        (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f32_le_quiet.c b/softfloat/source/f32_le_quiet.c
index c2d4297..329fe39 100644
--- a/softfloat/source/f32_le_quiet.c
+++ b/softfloat/source/f32_le_quiet.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_le_quiet( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f32_le_quiet( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF32UI( uiA );
+    signB = signF32UI( uiB );
+    return
+        (signA != signB) ? signA || ! (uint32_t) ((uiA | uiB)<<1)
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f32_lt.c b/softfloat/source/f32_lt.c
index 5b5fd22..ddc1804 100644
--- a/softfloat/source/f32_lt.c
+++ b/softfloat/source/f32_lt.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f32_lt( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f32_lt( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF32UI( uiA );
+    signB = signF32UI( uiB );
+    return
+        (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f32_lt_quiet.c b/softfloat/source/f32_lt_quiet.c
index 0153881..59c9cf1 100644
--- a/softfloat/source/f32_lt_quiet.c
+++ b/softfloat/source/f32_lt_quiet.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f32_lt_quiet( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF32UI( uiA );
-    signB = signF32UI( uiB );
-    return
-        (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f32_lt_quiet( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF32UI( uiA ) || isNaNF32UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF32UI( uiA ) || softfloat_isSigNaNF32UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF32UI( uiA );
+    signB = signF32UI( uiB );
+    return
+        (signA != signB) ? signA && ((uint32_t) ((uiA | uiB)<<1) != 0)
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f32_mul.c b/softfloat/source/f32_mul.c
index f5c8560..b1f8ec0 100644
--- a/softfloat/source/f32_mul.c
+++ b/softfloat/source/f32_mul.c
@@ -1,137 +1,137 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_mul( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    bool signZ;
-    uint_fast32_t magBits;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ, uiZ;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA  = expF32UI( uiA );
-    sigA  = fracF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF32UI( uiB );
-    expB  = expF32UI( uiB );
-    sigB  = fracF32UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0xFF ) {
-        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
-        magBits = expB | sigB;
-        goto infArg;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        magBits = expA | sigA;
-        goto infArg;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zero;
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x7F;
-    sigA = (sigA | 0x00800000)<<7;
-    sigB = (sigB | 0x00800000)<<8;
-    sigZ = softfloat_shortShiftRightJam64( (uint_fast64_t) sigA * sigB, 32 );
-    if ( sigZ < 0x40000000 ) {
-        --expZ;
-        sigZ <<= 1;
-    }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infArg:
-    if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ = defaultNaNF32UI;
-    } else {
-        uiZ = packToF32UI( signZ, 0xFF, 0 );
-    }
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF32UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f32_mul( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    bool signZ;
+    uint_fast32_t magBits;
+    struct exp16_sig32 normExpSig;
+    int_fast16_t expZ;
+    uint_fast32_t sigZ, uiZ;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF32UI( uiA );
+    expA  = expF32UI( uiA );
+    sigA  = fracF32UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF32UI( uiB );
+    expB  = expF32UI( uiB );
+    sigB  = fracF32UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0xFF ) {
+        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
+        magBits = expB | sigB;
+        goto infArg;
+    }
+    if ( expB == 0xFF ) {
+        if ( sigB ) goto propagateNaN;
+        magBits = expA | sigA;
+        goto infArg;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF32Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zero;
+        normExpSig = softfloat_normSubnormalF32Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x7F;
+    sigA = (sigA | 0x00800000)<<7;
+    sigB = (sigB | 0x00800000)<<8;
+    sigZ = softfloat_shortShiftRightJam64( (uint_fast64_t) sigA * sigB, 32 );
+    if ( sigZ < 0x40000000 ) {
+        --expZ;
+        sigZ <<= 1;
+    }
+    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infArg:
+    if ( ! magBits ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ = defaultNaNF32UI;
+    } else {
+        uiZ = packToF32UI( signZ, 0xFF, 0 );
+    }
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF32UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_mulAdd.c b/softfloat/source/f32_mulAdd.c
index 9a28e21..b77777e 100644
--- a/softfloat/source/f32_mulAdd.c
+++ b/softfloat/source/f32_mulAdd.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    union ui32_f32 uC;
-    uint_fast32_t uiC;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    uC.f = c;
-    uiC = uC.ui;
-    return softfloat_mulAddF32( uiA, uiB, uiC, 0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t f32_mulAdd( float32_t a, float32_t b, float32_t c )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    union ui32_f32 uC;
+    uint_fast32_t uiC;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    uC.f = c;
+    uiC = uC.ui;
+    return softfloat_mulAddF32( uiA, uiB, uiC, 0 );
+
+}
+
diff --git a/softfloat/source/f32_rem.c b/softfloat/source/f32_rem.c
index b29bf41..2d74c8c 100644
--- a/softfloat/source/f32_rem.c
+++ b/softfloat/source/f32_rem.c
@@ -1,168 +1,168 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_rem( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    struct exp16_sig32 normExpSig;
-    uint32_t rem;
-    int_fast16_t expDiff;
-    uint32_t q, recip32, altRem, meanRem;
-    bool signRem;
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA  = expF32UI( uiA );
-    sigA  = fracF32UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0xFF ) {
-        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
-        goto invalid;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN;
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    rem = sigA | 0x00800000;
-    sigB |= 0x00800000;
-    expDiff = expA - expB;
-    if ( expDiff < 1 ) {
-        if ( expDiff < -1 ) return a;
-        sigB <<= 6;
-        if ( expDiff ) {
-            rem <<= 5;
-            q = 0;
-        } else {
-            rem <<= 6;
-            q = (sigB <= rem);
-            if ( q ) rem -= sigB;
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( sigB<<8 );
-        /*--------------------------------------------------------------------
-        | Changing the shift of `rem' here requires also changing the initial
-        | subtraction from `expDiff'.
-        *--------------------------------------------------------------------*/
-        rem <<= 7;
-        expDiff -= 31;
-        /*--------------------------------------------------------------------
-        | The scale of `sigB' affects how many bits are obtained during each
-        | cycle of the loop.  Currently this is 29 bits per loop iteration,
-        | which is believed to be the maximum possible.
-        *--------------------------------------------------------------------*/
-        sigB <<= 6;
-        for (;;) {
-            q = (rem * (uint_fast64_t) recip32)>>32;
-            if ( expDiff < 0 ) break;
-            rem = -(q * (uint32_t) sigB);
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -30 here.)
-        *--------------------------------------------------------------------*/
-        q >>= ~expDiff & 31;
-        rem = (rem<<(expDiff + 30)) - q * (uint32_t) sigB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    do {
-        altRem = rem;
-        ++q;
-        rem -= sigB;
-    } while ( ! (rem & 0x80000000) );
-    meanRem = rem + altRem;
-    if ( (meanRem & 0x80000000) || (! meanRem && (q & 1)) ) rem = altRem;
-    signRem = signA;
-    if ( 0x80000000 <= rem ) {
-        signRem = ! signRem;
-        rem = -rem;
-    }
-    return softfloat_normRoundPackToF32( signRem, expB, rem );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f32_rem( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    struct exp16_sig32 normExpSig;
+    uint32_t rem;
+    int_fast16_t expDiff;
+    uint32_t q, recip32, altRem, meanRem;
+    bool signRem;
+    uint_fast32_t uiZ;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF32UI( uiA );
+    expA  = expF32UI( uiA );
+    sigA  = fracF32UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    expB = expF32UI( uiB );
+    sigB = fracF32UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0xFF ) {
+        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN;
+        goto invalid;
+    }
+    if ( expB == 0xFF ) {
+        if ( sigB ) goto propagateNaN;
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) goto invalid;
+        normExpSig = softfloat_normSubnormalF32Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF32Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    rem = sigA | 0x00800000;
+    sigB |= 0x00800000;
+    expDiff = expA - expB;
+    if ( expDiff < 1 ) {
+        if ( expDiff < -1 ) return a;
+        sigB <<= 6;
+        if ( expDiff ) {
+            rem <<= 5;
+            q = 0;
+        } else {
+            rem <<= 6;
+            q = (sigB <= rem);
+            if ( q ) rem -= sigB;
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( sigB<<8 );
+        /*--------------------------------------------------------------------
+        | Changing the shift of `rem' here requires also changing the initial
+        | subtraction from `expDiff'.
+        *--------------------------------------------------------------------*/
+        rem <<= 7;
+        expDiff -= 31;
+        /*--------------------------------------------------------------------
+        | The scale of `sigB' affects how many bits are obtained during each
+        | cycle of the loop.  Currently this is 29 bits per loop iteration,
+        | which is believed to be the maximum possible.
+        *--------------------------------------------------------------------*/
+        sigB <<= 6;
+        for (;;) {
+            q = (rem * (uint_fast64_t) recip32)>>32;
+            if ( expDiff < 0 ) break;
+            rem = -(q * (uint32_t) sigB);
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -30 here.)
+        *--------------------------------------------------------------------*/
+        q >>= ~expDiff & 31;
+        rem = (rem<<(expDiff + 30)) - q * (uint32_t) sigB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    do {
+        altRem = rem;
+        ++q;
+        rem -= sigB;
+    } while ( ! (rem & 0x80000000) );
+    meanRem = rem + altRem;
+    if ( (meanRem & 0x80000000) || (! meanRem && (q & 1)) ) rem = altRem;
+    signRem = signA;
+    if ( 0x80000000 <= rem ) {
+        signRem = ! signRem;
+        rem = -rem;
+    }
+    return softfloat_normRoundPackToF32( signRem, expB, rem );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    goto uiZ;
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF32UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_roundToInt.c b/softfloat/source/f32_roundToInt.c
index 305af79..801a769 100644
--- a/softfloat/source/f32_roundToInt.c
+++ b/softfloat/source/f32_roundToInt.c
@@ -1,120 +1,120 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t exp;
-    uint_fast32_t uiZ, lastBitMask, roundBitsMask;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp <= 0x7E ) {
-        if ( !(uint32_t) (uiA<<1) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        uiZ = uiA & packToF32UI( 1, 0, 0 );
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !fracF32UI( uiA ) ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0x7E ) uiZ |= packToF32UI( 0, 0x7F, 0 );
-            break;
-         case softfloat_round_min:
-            if ( uiZ ) uiZ = packToF32UI( 1, 0x7F, 0 );
-            break;
-         case softfloat_round_max:
-            if ( !uiZ ) uiZ = packToF32UI( 0, 0x7F, 0 );
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            uiZ |= packToF32UI( 0, 0x7F, 0 );
-            break;
-#endif
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x96 <= exp ) {
-        if ( (exp == 0xFF) && fracF32UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
-            goto uiZ;
-        }
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = uiA;
-    lastBitMask = (uint_fast32_t) 1<<(0x96 - exp);
-    roundBitsMask = lastBitMask - 1;
-    if ( roundingMode == softfloat_round_near_maxMag ) {
-        uiZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_near_even ) {
-        uiZ += lastBitMask>>1;
-        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
-    } else if (
-        roundingMode
-            == (signF32UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
-    ) {
-        uiZ += roundBitsMask;
-    }
-    uiZ &= ~roundBitsMask;
-    if ( uiZ != uiA ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f32_roundToInt( float32_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    int_fast16_t exp;
+    uint_fast32_t uiZ, lastBitMask, roundBitsMask;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp <= 0x7E ) {
+        if ( !(uint32_t) (uiA<<1) ) return a;
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        uiZ = uiA & packToF32UI( 1, 0, 0 );
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !fracF32UI( uiA ) ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0x7E ) uiZ |= packToF32UI( 0, 0x7F, 0 );
+            break;
+         case softfloat_round_min:
+            if ( uiZ ) uiZ = packToF32UI( 1, 0x7F, 0 );
+            break;
+         case softfloat_round_max:
+            if ( !uiZ ) uiZ = packToF32UI( 0, 0x7F, 0 );
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            uiZ |= packToF32UI( 0, 0x7F, 0 );
+            break;
+#endif
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x96 <= exp ) {
+        if ( (exp == 0xFF) && fracF32UI( uiA ) ) {
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            goto uiZ;
+        }
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = uiA;
+    lastBitMask = (uint_fast32_t) 1<<(0x96 - exp);
+    roundBitsMask = lastBitMask - 1;
+    if ( roundingMode == softfloat_round_near_maxMag ) {
+        uiZ += lastBitMask>>1;
+    } else if ( roundingMode == softfloat_round_near_even ) {
+        uiZ += lastBitMask>>1;
+        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
+    } else if (
+        roundingMode
+            == (signF32UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
+    ) {
+        uiZ += roundBitsMask;
+    }
+    uiZ &= ~roundBitsMask;
+    if ( uiZ != uiA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_sqrt.c b/softfloat/source/f32_sqrt.c
index 9263bde..9c6a998 100644
--- a/softfloat/source/f32_sqrt.c
+++ b/softfloat/source/f32_sqrt.c
@@ -1,121 +1,121 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f32_sqrt( float32_t a )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA, uiZ;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ, shiftedSigZ;
-    uint32_t negRem;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF32UI( uiA );
-    expA  = expF32UI( uiA );
-    sigA  = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0xFF ) {
-        if ( sigA ) {
-            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
-            goto uiZ;
-        }
-        if ( ! signA ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signA ) {
-        if ( ! (expA | sigA) ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x7F)>>1) + 0x7E;
-    expA &= 1;
-    sigA = (sigA | 0x00800000)<<8;
-    sigZ =
-        ((uint_fast64_t) sigA * softfloat_approxRecipSqrt32_1( expA, sigA ))
-            >>32;
-    if ( expA ) sigZ >>= 1;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sigZ += 2;
-    if ( (sigZ & 0x3F) < 2 ) {
-        shiftedSigZ = sigZ>>2;
-        negRem = shiftedSigZ * shiftedSigZ;
-        sigZ &= ~3;
-        if ( negRem & 0x80000000 ) {
-            sigZ |= 1;
-        } else {
-            if ( negRem ) --sigZ;
-        }
-    }
-    return softfloat_roundPackToF32( 0, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f32_sqrt( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast32_t sigA, uiZ;
+    struct exp16_sig32 normExpSig;
+    int_fast16_t expZ;
+    uint_fast32_t sigZ, shiftedSigZ;
+    uint32_t negRem;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF32UI( uiA );
+    expA  = expF32UI( uiA );
+    sigA  = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0xFF ) {
+        if ( sigA ) {
+            uiZ = softfloat_propagateNaNF32UI( uiA, 0 );
+            goto uiZ;
+        }
+        if ( ! signA ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signA ) {
+        if ( ! (expA | sigA) ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF32Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x7F)>>1) + 0x7E;
+    expA &= 1;
+    sigA = (sigA | 0x00800000)<<8;
+    sigZ =
+        ((uint_fast64_t) sigA * softfloat_approxRecipSqrt32_1( expA, sigA ))
+            >>32;
+    if ( expA ) sigZ >>= 1;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sigZ += 2;
+    if ( (sigZ & 0x3F) < 2 ) {
+        shiftedSigZ = sigZ>>2;
+        negRem = shiftedSigZ * shiftedSigZ;
+        sigZ &= ~3;
+        if ( negRem & 0x80000000 ) {
+            sigZ |= 1;
+        } else {
+            if ( negRem ) --sigZ;
+        }
+    }
+    return softfloat_roundPackToF32( 0, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF32UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_sub.c b/softfloat/source/f32_sub.c
index 383484d..edbcd2f 100644
--- a/softfloat/source/f32_sub.c
+++ b/softfloat/source/f32_sub.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t f32_sub( float32_t a, float32_t b )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    union ui32_f32 uB;
-    uint_fast32_t uiB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
-    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
-    if ( signF32UI( uiA ^ uiB ) ) {
-        return softfloat_addMagsF32( uiA, uiB );
-    } else {
-        return softfloat_subMagsF32( uiA, uiB );
-    }
-#else
-    magsFuncPtr =
-        signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
-    return (*magsFuncPtr)( uiA, uiB );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t f32_sub( float32_t a, float32_t b )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    union ui32_f32 uB;
+    uint_fast32_t uiB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 1)
+    float32_t (*magsFuncPtr)( uint_fast32_t, uint_fast32_t );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
+    if ( signF32UI( uiA ^ uiB ) ) {
+        return softfloat_addMagsF32( uiA, uiB );
+    } else {
+        return softfloat_subMagsF32( uiA, uiB );
+    }
+#else
+    magsFuncPtr =
+        signF32UI( uiA ^ uiB ) ? softfloat_addMagsF32 : softfloat_subMagsF32;
+    return (*magsFuncPtr)( uiA, uiB );
+#endif
+
+}
+
diff --git a/softfloat/source/f32_to_bf16.c b/softfloat/source/f32_to_bf16.c
new file mode 100644
index 0000000..6f81493
--- /dev/null
+++ b/softfloat/source/f32_to_bf16.c
@@ -0,0 +1,105 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#include <inttypes.h>
+#include <stdio.h>
+
+bfloat16_t f32_to_bf16( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ, frac16;
+    union ui16_bf16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // infinity or NaN cases
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            // NaN case
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToBF16UI( &commonNaN );
+        } else {
+            // infinity case
+            uiZ = packToBF16UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // frac is a 24-bit mantissa, right shifted by 9
+    // In the normal case, (24-9) = 15 are set 
+    frac16 = frac>>9 | ((frac & 0x1FF) != 0);
+    if ( ! (exp | frac16) ) {
+        uiZ = packToBF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // softfloat_roundPackToBF16 exponent argument (2nd argument)
+    // must correspond to the exponent of fracIn[13] bits
+    // (fracIn is the 3rd and last argument) 
+    uint_fast32_t mask = exp ? 0x4000 : 0x0; // implicit one mask added if input is a normal number
+    // exponent for the lowest normal and largest subnormal should be equal
+    // but is not in IEEE encoding so mantissa must be partially normalized
+    // (by one bit) for subnormal numbers. Such that (exp - 1) corresponds
+    // to the exponent of frac16[13]
+    frac16 = frac16 << (exp ? 0 : 1);
+    return softfloat_roundPackToBF16( sign, exp - 1, frac16 | mask );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_to_extF80.c b/softfloat/source/f32_to_extF80.c
index 742ed64..8d35457 100644
--- a/softfloat/source/f32_to_extF80.c
+++ b/softfloat/source/f32_to_extF80.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t f32_to_extF80( float32_t a )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    struct exp16_sig32 normExpSig;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
-            uiZ64 = uiZ.v64;
-            uiZ0  = uiZ.v0;
-        } else {
-            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-            uiZ0  = UINT64_C( 0x8000000000000000 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 );
-    uiZ0  = (uint_fast64_t) (frac | 0x00800000)<<40;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t f32_to_extF80( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    struct exp16_sig32 normExpSig;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
+            uiZ64 = uiZ.v64;
+            uiZ0  = uiZ.v0;
+        } else {
+            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+            uiZ0  = UINT64_C( 0x8000000000000000 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 );
+    uiZ0  = (uint_fast64_t) (frac | 0x00800000)<<40;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_to_extF80M.c b/softfloat/source/f32_to_extF80M.c
index af7e32a..03580fd 100644
--- a/softfloat/source/f32_to_extF80M.c
+++ b/softfloat/source/f32_to_extF80M.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = f32_to_extF80( a );
-
-}
-
-#else
-
-void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    union ui32_f32 uA;
-    uint32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint32_t frac;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ64;
-    uint32_t uiZ32;
-    struct exp16_sig32 normExpSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zSPtr = (struct extFloat80M *) zPtr;
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
-            return;
-        }
-        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-        uiZ32 = 0x80000000;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ32 = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 );
-    uiZ32 = 0x80000000 | (uint32_t) frac<<8;
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = (uint64_t) uiZ32<<32;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = f32_to_extF80( a );
+
+}
+
+#else
+
+void f32_to_extF80M( float32_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    union ui32_f32 uA;
+    uint32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint32_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ64;
+    uint32_t uiZ32;
+    struct exp16_sig32 normExpSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zSPtr = (struct extFloat80M *) zPtr;
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
+            return;
+        }
+        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+        uiZ32 = 0x80000000;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ32 = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3F80 );
+    uiZ32 = 0x80000000 | (uint32_t) frac<<8;
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = (uint64_t) uiZ32<<32;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f32_to_f128.c b/softfloat/source/f32_to_f128.c
index 6a765a4..ee0b414 100644
--- a/softfloat/source/f32_to_f128.c
+++ b/softfloat/source/f32_to_f128.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f32_to_f128( float32_t a )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    struct exp16_sig32 normExpSig;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
-        } else {
-            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
-            uiZ.v0  = 0;
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ.v64 = packToF128UI64( sign, 0, 0 );
-            uiZ.v0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ.v64 = packToF128UI64( sign, exp + 0x3F80, (uint_fast64_t) frac<<25 );
-    uiZ.v0  = 0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f32_to_f128( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    struct exp16_sig32 normExpSig;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
+        } else {
+            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
+            uiZ.v0  = 0;
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ.v64 = packToF128UI64( sign, 0, 0 );
+            uiZ.v0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ.v64 = packToF128UI64( sign, exp + 0x3F80, (uint_fast64_t) frac<<25 );
+    uiZ.v0  = 0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_to_f128M.c b/softfloat/source/f32_to_f128M.c
index ee7e6b3..cd3ad69 100644
--- a/softfloat/source/f32_to_f128M.c
+++ b/softfloat/source/f32_to_f128M.c
@@ -1,115 +1,115 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f32_to_f128M( float32_t a, float128_t *zPtr )
-{
-
-    *zPtr = f32_to_f128( a );
-
-}
-
-#else
-
-void f32_to_f128M( float32_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr;
-    union ui32_f32 uA;
-    uint32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint32_t frac, uiZ64;
-    struct commonNaN commonNaN;
-    uint32_t uiZ96;
-    struct exp16_sig32 normExpSig;
-    uint64_t frac64;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = 0;
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
-            return;
-        }
-        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ96 = packToF128UI96( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac64 = (uint64_t) frac<<25;
-    uiZ96 = packToF128UI96( sign, exp + 0x3F80, frac64>>32 );
-    uiZ64 = frac64;
- uiZ:
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = uiZ64;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f32_to_f128M( float32_t a, float128_t *zPtr )
+{
+
+    *zPtr = f32_to_f128( a );
+
+}
+
+#else
+
+void f32_to_f128M( float32_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr;
+    union ui32_f32 uA;
+    uint32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint32_t frac, uiZ64;
+    struct commonNaN commonNaN;
+    uint32_t uiZ96;
+    struct exp16_sig32 normExpSig;
+    uint64_t frac64;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = 0;
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
+            return;
+        }
+        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ96 = packToF128UI96( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac64 = (uint64_t) frac<<25;
+    uiZ96 = packToF128UI96( sign, exp + 0x3F80, frac64>>32 );
+    uiZ64 = frac64;
+ uiZ:
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = uiZ64;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f32_to_f16.c b/softfloat/source/f32_to_f16.c
index a9e77b7..45005fe 100644
--- a/softfloat/source/f32_to_f16.c
+++ b/softfloat/source/f32_to_f16.c
@@ -1,88 +1,91 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f32_to_f16( float32_t a )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t frac;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ, frac16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac16 = frac>>9 | ((frac & 0x1FF) != 0);
-    if ( ! (exp | frac16) ) {
-        uiZ = packToF16UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f32_to_f16( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ, frac16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    // frac is a 24-bit significand, the bottom 9 bits LSB are extracted and OR-red
+    // into a sticky flag, the top 15 MSBs are extracted, the LSB of this top slice
+    // is OR-red with the sticky 
+    frac16 = frac>>9 | ((frac & 0x1FF) != 0);
+    if ( ! (exp | frac16) ) {
+        uiZ = packToF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    return softfloat_roundPackToF16( sign, exp - 0x71, frac16 | 0x4000 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_to_f64.c b/softfloat/source/f32_to_f64.c
index 4f97519..6cd08ed 100644
--- a/softfloat/source/f32_to_f64.c
+++ b/softfloat/source/f32_to_f64.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f32_to_f64( float32_t a )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t frac;
-    struct commonNaN commonNaN;
-    uint_fast64_t uiZ;
-    struct exp16_sig32 normExpSig;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    frac = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0xFF ) {
-        if ( frac ) {
-            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
-        } else {
-            uiZ = packToF64UI( sign, 0x7FF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ = packToF64UI( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) frac<<29 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f32_to_f64( float32_t a )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t frac;
+    struct commonNaN commonNaN;
+    uint_fast64_t uiZ;
+    struct exp16_sig32 normExpSig;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    frac = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0xFF ) {
+        if ( frac ) {
+            softfloat_f32UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF64UI( &commonNaN );
+        } else {
+            uiZ = packToF64UI( sign, 0x7FF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ = packToF64UI( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = packToF64UI( sign, exp + 0x380, (uint_fast64_t) frac<<29 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f32_to_i32.c b/softfloat/source/f32_to_i32.c
index 7d0356f..241ab8e 100644
--- a/softfloat/source/f32_to_i32.c
+++ b/softfloat/source/f32_to_i32.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    uint_fast64_t sig64;
-    int_fast16_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    sig  = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
-    if ( (exp == 0xFF) && sig ) {
-#if (i32_fromNaN == i32_fromPosOverflow)
-        sign = 0;
-#elif (i32_fromNaN == i32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return i32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= 0x00800000;
-    sig64 = (uint_fast64_t) sig<<32;
-    shiftDist = 0xAA - exp;
-    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f32_to_i32( float32_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    uint_fast64_t sig64;
+    int_fast16_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    sig  = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+    if ( (exp == 0xFF) && sig ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+        sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return i32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= 0x00800000;
+    sig64 = (uint_fast64_t) sig<<32;
+    shiftDist = 0xAA - exp;
+    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    return softfloat_roundToI32( sign, sig64, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f32_to_i32_r_minMag.c b/softfloat/source/f32_to_i32_r_minMag.c
index 7652f2e..f8134f4 100644
--- a/softfloat/source/f32_to_i32_r_minMag.c
+++ b/softfloat/source/f32_to_i32_r_minMag.c
@@ -1,89 +1,89 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    int_fast32_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF32UI( uiA );
-    sig = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x9E - exp;
-    if ( 32 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF32UI( uiA );
-    if ( shiftDist <= 0 ) {
-        if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1;
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = (sig | 0x00800000)<<8;
-    absZ = sig>>shiftDist;
-    if ( exact && ((uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f32_to_i32_r_minMag( float32_t a, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    int_fast32_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF32UI( uiA );
+    sig = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x9E - exp;
+    if ( 32 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF32UI( uiA );
+    if ( shiftDist <= 0 ) {
+        if ( uiA == packToF32UI( 1, 0x9E, 0 ) ) return -0x7FFFFFFF - 1;
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig | 0x00800000)<<8;
+    absZ = sig>>shiftDist;
+    if ( exact && ((uint_fast32_t) absZ<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f32_to_i64.c b/softfloat/source/f32_to_i64.c
index 4b12544..816bc7b 100644
--- a/softfloat/source/f32_to_i64.c
+++ b/softfloat/source/f32_to_i64.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-#ifdef SOFTFLOAT_FAST_INT64
-    uint_fast64_t sig64, extra;
-    struct uint64_extra sig64Extra;
-#else
-    uint32_t extSig[3];
-#endif
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    sig  = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0xBE - exp;
-    if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= 0x00800000;
-#ifdef SOFTFLOAT_FAST_INT64
-    sig64 = (uint_fast64_t) sig<<40;
-    extra = 0;
-    if ( shiftDist ) {
-        sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
-        sig64 = sig64Extra.v;
-        extra = sig64Extra.extra;
-    }
-    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
-#else
-    extSig[indexWord( 3, 2 )] = sig<<8;
-    extSig[indexWord( 3, 1 )] = 0;
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f32_to_i64( float32_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+#ifdef SOFTFLOAT_FAST_INT64
+    uint_fast64_t sig64, extra;
+    struct uint64_extra sig64Extra;
+#else
+    uint32_t extSig[3];
+#endif
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    sig  = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0xBE - exp;
+    if ( shiftDist < 0 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= 0x00800000;
+#ifdef SOFTFLOAT_FAST_INT64
+    sig64 = (uint_fast64_t) sig<<40;
+    extra = 0;
+    if ( shiftDist ) {
+        sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
+        sig64 = sig64Extra.v;
+        extra = sig64Extra.extra;
+    }
+    return softfloat_roundToI64( sign, sig64, extra, roundingMode, exact );
+#else
+    extSig[indexWord( 3, 2 )] = sig<<8;
+    extSig[indexWord( 3, 1 )] = 0;
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+#endif
+
+}
+
diff --git a/softfloat/source/f32_to_i64_r_minMag.c b/softfloat/source/f32_to_i64_r_minMag.c
index 397ddf6..346f6b8 100644
--- a/softfloat/source/f32_to_i64_r_minMag.c
+++ b/softfloat/source/f32_to_i64_r_minMag.c
@@ -1,94 +1,94 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    uint_fast64_t sig64;
-    int_fast64_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF32UI( uiA );
-    sig = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0xBE - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF32UI( uiA );
-    if ( shiftDist <= 0 ) {
-        if ( uiA == packToF32UI( 1, 0xBE, 0 ) ) {
-            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? i64_fromNaN
-                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig |= 0x00800000;
-    sig64 = (uint_fast64_t) sig<<40;
-    absZ = sig64>>shiftDist;
-    shiftDist = 40 - shiftDist;
-    if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f32_to_i64_r_minMag( float32_t a, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    uint_fast64_t sig64;
+    int_fast64_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF32UI( uiA );
+    sig = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0xBE - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF32UI( uiA );
+    if ( shiftDist <= 0 ) {
+        if ( uiA == packToF32UI( 1, 0xBE, 0 ) ) {
+            return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? i64_fromNaN
+                : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig |= 0x00800000;
+    sig64 = (uint_fast64_t) sig<<40;
+    absZ = sig64>>shiftDist;
+    shiftDist = 40 - shiftDist;
+    if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f32_to_ui32.c b/softfloat/source/f32_to_ui32.c
index cb47d94..32d9eac 100644
--- a/softfloat/source/f32_to_ui32.c
+++ b/softfloat/source/f32_to_ui32.c
@@ -1,84 +1,84 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    uint_fast64_t sig64;
-    int_fast16_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    sig  = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
-    if ( (exp == 0xFF) && sig ) {
-#if (ui32_fromNaN == ui32_fromPosOverflow)
-        sign = 0;
-#elif (ui32_fromNaN == ui32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return ui32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= 0x00800000;
-    sig64 = (uint_fast64_t) sig<<32;
-    shiftDist = 0xAA - exp;
-    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
-    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f32_to_ui32( float32_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    uint_fast64_t sig64;
+    int_fast16_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    sig  = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+    if ( (exp == 0xFF) && sig ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+        sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return ui32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= 0x00800000;
+    sig64 = (uint_fast64_t) sig<<32;
+    shiftDist = 0xAA - exp;
+    if ( 0 < shiftDist ) sig64 = softfloat_shiftRightJam64( sig64, shiftDist );
+    return softfloat_roundToUI32( sign, sig64, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f32_to_ui32_r_minMag.c b/softfloat/source/f32_to_ui32_r_minMag.c
index cdeb75f..a90ef92 100644
--- a/softfloat/source/f32_to_ui32_r_minMag.c
+++ b/softfloat/source/f32_to_ui32_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    uint_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF32UI( uiA );
-    sig = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x9E - exp;
-    if ( 32 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF32UI( uiA );
-    if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = (sig | 0x00800000)<<8;
-    z = sig>>shiftDist;
-    if ( exact && (z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f32_to_ui32_r_minMag( float32_t a, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    uint_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF32UI( uiA );
+    sig = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x9E - exp;
+    if ( 32 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF32UI( uiA );
+    if ( sign || (shiftDist < 0) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig | 0x00800000)<<8;
+    z = sig>>shiftDist;
+    if ( exact && (z<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/f32_to_ui64.c b/softfloat/source/f32_to_ui64.c
index 61f204a..16e608a 100644
--- a/softfloat/source/f32_to_ui64.c
+++ b/softfloat/source/f32_to_ui64.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-#ifdef SOFTFLOAT_FAST_INT64
-    uint_fast64_t sig64, extra;
-    struct uint64_extra sig64Extra;
-#else
-    uint32_t extSig[3];
-#endif
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF32UI( uiA );
-    exp  = expF32UI( uiA );
-    sig  = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0xBE - exp;
-    if ( shiftDist < 0 ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= 0x00800000;
-#ifdef SOFTFLOAT_FAST_INT64
-    sig64 = (uint_fast64_t) sig<<40;
-    extra = 0;
-    if ( shiftDist ) {
-        sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
-        sig64 = sig64Extra.v;
-        extra = sig64Extra.extra;
-    }
-    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact );
-#else
-    extSig[indexWord( 3, 2 )] = sig<<8;
-    extSig[indexWord( 3, 1 )] = 0;
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f32_to_ui64( float32_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+#ifdef SOFTFLOAT_FAST_INT64
+    uint_fast64_t sig64, extra;
+    struct uint64_extra sig64Extra;
+#else
+    uint32_t extSig[3];
+#endif
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF32UI( uiA );
+    exp  = expF32UI( uiA );
+    sig  = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0xBE - exp;
+    if ( shiftDist < 0 ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= 0x00800000;
+#ifdef SOFTFLOAT_FAST_INT64
+    sig64 = (uint_fast64_t) sig<<40;
+    extra = 0;
+    if ( shiftDist ) {
+        sig64Extra = softfloat_shiftRightJam64Extra( sig64, 0, shiftDist );
+        sig64 = sig64Extra.v;
+        extra = sig64Extra.extra;
+    }
+    return softfloat_roundToUI64( sign, sig64, extra, roundingMode, exact );
+#else
+    extSig[indexWord( 3, 2 )] = sig<<8;
+    extSig[indexWord( 3, 1 )] = 0;
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist ) softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+#endif
+
+}
+
diff --git a/softfloat/source/f32_to_ui64_r_minMag.c b/softfloat/source/f32_to_ui64_r_minMag.c
index c0fe54f..69e0064 100644
--- a/softfloat/source/f32_to_ui64_r_minMag.c
+++ b/softfloat/source/f32_to_ui64_r_minMag.c
@@ -1,90 +1,90 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
-{
-    union ui32_f32 uA;
-    uint_fast32_t uiA;
-    int_fast16_t exp;
-    uint_fast32_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    uint_fast64_t sig64, z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF32UI( uiA );
-    sig = fracF32UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0xBE - exp;
-    if ( 64 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF32UI( uiA );
-    if ( sign || (shiftDist < 0) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0xFF) && sig ? ui64_fromNaN
-                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig |= 0x00800000;
-    sig64 = (uint_fast64_t) sig<<40;
-    z = sig64>>shiftDist;
-    shiftDist = 40 - shiftDist;
-    if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f32_to_ui64_r_minMag( float32_t a, bool exact )
+{
+    union ui32_f32 uA;
+    uint_fast32_t uiA;
+    int_fast16_t exp;
+    uint_fast32_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    uint_fast64_t sig64, z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF32UI( uiA );
+    sig = fracF32UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0xBE - exp;
+    if ( 64 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF32UI( uiA );
+    if ( sign || (shiftDist < 0) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0xFF) && sig ? ui64_fromNaN
+                : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig |= 0x00800000;
+    sig64 = (uint_fast64_t) sig<<40;
+    z = sig64>>shiftDist;
+    shiftDist = 40 - shiftDist;
+    if ( exact && (shiftDist < 0) && (uint32_t) (sig<<(shiftDist & 31)) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/f64_add.c b/softfloat/source/f64_add.c
index 42f840d..878f6da 100644
--- a/softfloat/source/f64_add.c
+++ b/softfloat/source/f64_add.c
@@ -1,74 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t f64_add( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_addMagsF64( uiA, uiB, signA );
-    } else {
-        return softfloat_subMagsF64( uiA, uiB, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t f64_add( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF64UI( uiB );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_addMagsF64( uiA, uiB, signA );
+    } else {
+        return softfloat_subMagsF64( uiA, uiB, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_addMagsF64 : softfloat_subMagsF64;
+    return (*magsFuncPtr)( uiA, uiB, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/f64_div.c b/softfloat/source/f64_div.c
index 9c967bb..7f5eddd 100644
--- a/softfloat/source/f64_div.c
+++ b/softfloat/source/f64_div.c
@@ -1,172 +1,172 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_div( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    bool signZ;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-    uint32_t recip32, sig32Z, doubleTerm;
-    uint_fast64_t rem;
-    uint32_t q;
-    uint_fast64_t sigZ;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    expB  = expF64UI( uiB );
-    sigB  = fracF64UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA ) goto propagateNaN;
-        if ( expB == 0x7FF ) {
-            if ( sigB ) goto propagateNaN;
-            goto invalid;
-        }
-        goto infinity;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        goto zero;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) {
-            if ( ! (expA | sigA) ) goto invalid;
-            softfloat_raiseFlags( softfloat_flag_infinite );
-            goto infinity;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA - expB + 0x3FE;
-    sigA |= UINT64_C( 0x0010000000000000 );
-    sigB |= UINT64_C( 0x0010000000000000 );
-    if ( sigA < sigB ) {
-        --expZ;
-        sigA <<= 11;
-    } else {
-        sigA <<= 10;
-    }
-    sigB <<= 11;
-    recip32 = softfloat_approxRecip32_1( sigB>>32 ) - 2;
-    sig32Z = ((uint32_t) (sigA>>32) * (uint_fast64_t) recip32)>>32;
-    doubleTerm = sig32Z<<1;
-    rem =
-        ((sigA - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28)
-            - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4);
-    q = (((uint32_t) (rem>>32) * (uint_fast64_t) recip32)>>32) + 4;
-    sigZ = ((uint_fast64_t) sig32Z<<32) + ((uint_fast64_t) q<<4);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (sigZ & 0x1FF) < 4<<4 ) {
-        q &= ~7;
-        sigZ &= ~(uint_fast64_t) 0x7F;
-        doubleTerm = q<<1;
-        rem =
-            ((rem - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28)
-                - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4);
-        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
-            sigZ -= 1<<7;
-        } else {
-            if ( rem ) sigZ |= 1;
-        }
-    }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infinity:
-    uiZ = packToF64UI( signZ, 0x7FF, 0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF64UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f64_div( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    bool signZ;
+    struct exp16_sig64 normExpSig;
+    int_fast16_t expZ;
+    uint32_t recip32, sig32Z, doubleTerm;
+    uint_fast64_t rem;
+    uint32_t q;
+    uint_fast64_t sigZ;
+    uint_fast64_t uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF64UI( uiB );
+    expB  = expF64UI( uiB );
+    sigB  = fracF64UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA ) goto propagateNaN;
+        if ( expB == 0x7FF ) {
+            if ( sigB ) goto propagateNaN;
+            goto invalid;
+        }
+        goto infinity;
+    }
+    if ( expB == 0x7FF ) {
+        if ( sigB ) goto propagateNaN;
+        goto zero;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) {
+            if ( ! (expA | sigA) ) goto invalid;
+            softfloat_raiseFlags( softfloat_flag_infinite );
+            goto infinity;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA - expB + 0x3FE;
+    sigA |= UINT64_C( 0x0010000000000000 );
+    sigB |= UINT64_C( 0x0010000000000000 );
+    if ( sigA < sigB ) {
+        --expZ;
+        sigA <<= 11;
+    } else {
+        sigA <<= 10;
+    }
+    sigB <<= 11;
+    recip32 = softfloat_approxRecip32_1( sigB>>32 ) - 2;
+    sig32Z = ((uint32_t) (sigA>>32) * (uint_fast64_t) recip32)>>32;
+    doubleTerm = sig32Z<<1;
+    rem =
+        ((sigA - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28)
+            - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4);
+    q = (((uint32_t) (rem>>32) * (uint_fast64_t) recip32)>>32) + 4;
+    sigZ = ((uint_fast64_t) sig32Z<<32) + ((uint_fast64_t) q<<4);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (sigZ & 0x1FF) < 4<<4 ) {
+        q &= ~7;
+        sigZ &= ~(uint_fast64_t) 0x7F;
+        doubleTerm = q<<1;
+        rem =
+            ((rem - (uint_fast64_t) doubleTerm * (uint32_t) (sigB>>32))<<28)
+                - (uint_fast64_t) doubleTerm * ((uint32_t) sigB>>4);
+        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
+            sigZ -= 1<<7;
+        } else {
+            if ( rem ) sigZ |= 1;
+        }
+    }
+    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF64UI;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infinity:
+    uiZ = packToF64UI( signZ, 0x7FF, 0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF64UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_eq.c b/softfloat/source/f64_eq.c
index 3602003..e075c02 100644
--- a/softfloat/source/f64_eq.c
+++ b/softfloat/source/f64_eq.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_eq( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f64_eq( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ));
+
+}
+
diff --git a/softfloat/source/f64_eq_signaling.c b/softfloat/source/f64_eq_signaling.c
index 5daa179..d7e89a2 100644
--- a/softfloat/source/f64_eq_signaling.c
+++ b/softfloat/source/f64_eq_signaling.c
@@ -1,61 +1,61 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_eq_signaling( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f64_eq_signaling( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    return (uiA == uiB) || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ));
+
+}
+
diff --git a/softfloat/source/f64_isSignalingNaN.c b/softfloat/source/f64_isSignalingNaN.c
index e5d3832..5e1411f 100644
--- a/softfloat/source/f64_isSignalingNaN.c
+++ b/softfloat/source/f64_isSignalingNaN.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_isSignalingNaN( float64_t a )
-{
-    union ui64_f64 uA;
-
-    uA.f = a;
-    return softfloat_isSigNaNF64UI( uA.ui );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f64_isSignalingNaN( float64_t a )
+{
+    union ui64_f64 uA;
+
+    uA.f = a;
+    return softfloat_isSigNaNF64UI( uA.ui );
+
+}
+
diff --git a/softfloat/source/f64_le.c b/softfloat/source/f64_le.c
index 0b43d04..a96808f 100644
--- a/softfloat/source/f64_le.c
+++ b/softfloat/source/f64_le.c
@@ -1,67 +1,67 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_le( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        (signA != signB)
-            ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f64_le( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF64UI( uiA );
+    signB = signF64UI( uiB );
+    return
+        (signA != signB)
+            ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f64_le_quiet.c b/softfloat/source/f64_le_quiet.c
index 832eee7..942afba 100644
--- a/softfloat/source/f64_le_quiet.c
+++ b/softfloat/source/f64_le_quiet.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_le_quiet( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        (signA != signB)
-            ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            : (uiA == uiB) || (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f64_le_quiet( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF64UI( uiA );
+    signB = signF64UI( uiB );
+    return
+        (signA != signB)
+            ? signA || ! ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            : (uiA == uiB) || (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f64_lt.c b/softfloat/source/f64_lt.c
index 49ee05b..d9cf5aa 100644
--- a/softfloat/source/f64_lt.c
+++ b/softfloat/source/f64_lt.c
@@ -1,67 +1,67 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-bool f64_lt( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        (signA != signB)
-            ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+bool f64_lt( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return false;
+    }
+    signA = signF64UI( uiA );
+    signB = signF64UI( uiB );
+    return
+        (signA != signB)
+            ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f64_lt_quiet.c b/softfloat/source/f64_lt_quiet.c
index d640880..89d30bc 100644
--- a/softfloat/source/f64_lt_quiet.c
+++ b/softfloat/source/f64_lt_quiet.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-bool f64_lt_quiet( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signA, signB;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
-        if (
-            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
-        ) {
-            softfloat_raiseFlags( softfloat_flag_invalid );
-        }
-        return false;
-    }
-    signA = signF64UI( uiA );
-    signB = signF64UI( uiB );
-    return
-        (signA != signB)
-            ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-            : (uiA != uiB) && (signA ^ (uiA < uiB));
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+bool f64_lt_quiet( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signA, signB;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    if ( isNaNF64UI( uiA ) || isNaNF64UI( uiB ) ) {
+        if (
+            softfloat_isSigNaNF64UI( uiA ) || softfloat_isSigNaNF64UI( uiB )
+        ) {
+            softfloat_raiseFlags( softfloat_flag_invalid );
+        }
+        return false;
+    }
+    signA = signF64UI( uiA );
+    signB = signF64UI( uiB );
+    return
+        (signA != signB)
+            ? signA && ((uiA | uiB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+            : (uiA != uiB) && (signA ^ (uiA < uiB));
+
+}
+
diff --git a/softfloat/source/f64_mul.c b/softfloat/source/f64_mul.c
index 222e91d..38bdc85 100644
--- a/softfloat/source/f64_mul.c
+++ b/softfloat/source/f64_mul.c
@@ -1,150 +1,150 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_mul( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    bool signZ;
-    uint_fast64_t magBits;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-#ifdef SOFTFLOAT_FAST_INT64
-    struct uint128 sig128Z;
-#else
-    uint32_t sig128Z[4];
-#endif
-    uint_fast64_t sigZ, uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-    expB  = expF64UI( uiB );
-    sigB  = fracF64UI( uiB );
-    signZ = signA ^ signB;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
-        magBits = expB | sigB;
-        goto infArg;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        magBits = expA | sigA;
-        goto infArg;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zero;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zero;
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FF;
-    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
-    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;
-#ifdef SOFTFLOAT_FAST_INT64
-    sig128Z = softfloat_mul64To128( sigA, sigB );
-    sigZ = sig128Z.v64 | (sig128Z.v0 != 0);
-#else
-    softfloat_mul64To128M( sigA, sigB, sig128Z );
-    sigZ =
-        (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )];
-    if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
-#endif
-    if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
-        --expZ;
-        sigZ <<= 1;
-    }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infArg:
-    if ( ! magBits ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ = defaultNaNF64UI;
-    } else {
-        uiZ = packToF64UI( signZ, 0x7FF, 0 );
-    }
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zero:
-    uiZ = packToF64UI( signZ, 0, 0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f64_mul( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    bool signZ;
+    uint_fast64_t magBits;
+    struct exp16_sig64 normExpSig;
+    int_fast16_t expZ;
+#ifdef SOFTFLOAT_FAST_INT64
+    struct uint128 sig128Z;
+#else
+    uint32_t sig128Z[4];
+#endif
+    uint_fast64_t sigZ, uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF64UI( uiB );
+    expB  = expF64UI( uiB );
+    sigB  = fracF64UI( uiB );
+    signZ = signA ^ signB;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
+        magBits = expB | sigB;
+        goto infArg;
+    }
+    if ( expB == 0x7FF ) {
+        if ( sigB ) goto propagateNaN;
+        magBits = expA | sigA;
+        goto infArg;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zero;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zero;
+        normExpSig = softfloat_normSubnormalF64Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FF;
+    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
+    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;
+#ifdef SOFTFLOAT_FAST_INT64
+    sig128Z = softfloat_mul64To128( sigA, sigB );
+    sigZ = sig128Z.v64 | (sig128Z.v0 != 0);
+#else
+    softfloat_mul64To128M( sigA, sigB, sig128Z );
+    sigZ =
+        (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )];
+    if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
+#endif
+    if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
+        --expZ;
+        sigZ <<= 1;
+    }
+    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infArg:
+    if ( ! magBits ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ = defaultNaNF64UI;
+    } else {
+        uiZ = packToF64UI( signZ, 0x7FF, 0 );
+    }
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zero:
+    uiZ = packToF64UI( signZ, 0, 0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_mulAdd.c b/softfloat/source/f64_mulAdd.c
index fea3d96..13fc382 100644
--- a/softfloat/source/f64_mulAdd.c
+++ b/softfloat/source/f64_mulAdd.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    union ui64_f64 uC;
-    uint_fast64_t uiC;
-
-    uA.f = a;
-    uiA = uA.ui;
-    uB.f = b;
-    uiB = uB.ui;
-    uC.f = c;
-    uiC = uC.ui;
-    return softfloat_mulAddF64( uiA, uiB, uiC, 0 );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t f64_mulAdd( float64_t a, float64_t b, float64_t c )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    union ui64_f64 uC;
+    uint_fast64_t uiC;
+
+    uA.f = a;
+    uiA = uA.ui;
+    uB.f = b;
+    uiB = uB.ui;
+    uC.f = c;
+    uiC = uC.ui;
+    return softfloat_mulAddF64( uiA, uiB, uiC, 0 );
+
+}
+
diff --git a/softfloat/source/f64_rem.c b/softfloat/source/f64_rem.c
index ffce679..ca5350c 100644
--- a/softfloat/source/f64_rem.c
+++ b/softfloat/source/f64_rem.c
@@ -1,189 +1,189 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_rem( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    struct exp16_sig64 normExpSig;
-    uint64_t rem;
-    int_fast16_t expDiff;
-    uint32_t q, recip32;
-    uint_fast64_t q64;
-    uint64_t altRem, meanRem;
-    bool signRem;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
-        goto invalid;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN;
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA < expB - 1 ) return a;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expB ) {
-        if ( ! sigB ) goto invalid;
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    rem = sigA | UINT64_C( 0x0010000000000000 );
-    sigB |= UINT64_C( 0x0010000000000000 );
-    expDiff = expA - expB;
-    if ( expDiff < 1 ) {
-        if ( expDiff < -1 ) return a;
-        sigB <<= 9;
-        if ( expDiff ) {
-            rem <<= 8;
-            q = 0;
-        } else {
-            rem <<= 9;
-            q = (sigB <= rem);
-            if ( q ) rem -= sigB;
-        }
-    } else {
-        recip32 = softfloat_approxRecip32_1( sigB>>21 );
-        /*--------------------------------------------------------------------
-        | Changing the shift of `rem' here requires also changing the initial
-        | subtraction from `expDiff'.
-        *--------------------------------------------------------------------*/
-        rem <<= 9;
-        expDiff -= 30;
-        /*--------------------------------------------------------------------
-        | The scale of `sigB' affects how many bits are obtained during each
-        | cycle of the loop.  Currently this is 29 bits per loop iteration,
-        | the maximum possible.
-        *--------------------------------------------------------------------*/
-        sigB <<= 9;
-        for (;;) {
-            q64 = (uint32_t) (rem>>32) * (uint_fast64_t) recip32;
-            if ( expDiff < 0 ) break;
-            q = (q64 + 0x80000000)>>32;
-#ifdef SOFTFLOAT_FAST_INT64
-            rem <<= 29;
-#else
-            rem = (uint_fast64_t) (uint32_t) (rem>>3)<<32;
-#endif
-            rem -= q * (uint64_t) sigB;
-            if ( rem & UINT64_C( 0x8000000000000000 ) ) rem += sigB;
-            expDiff -= 29;
-        }
-        /*--------------------------------------------------------------------
-        | (`expDiff' cannot be less than -29 here.)
-        *--------------------------------------------------------------------*/
-        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
-        rem = (rem<<(expDiff + 30)) - q * (uint64_t) sigB;
-        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
-            altRem = rem + sigB;
-            goto selectRem;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    do {
-        altRem = rem;
-        ++q;
-        rem -= sigB;
-    } while ( ! (rem & UINT64_C( 0x8000000000000000 )) );
- selectRem:
-    meanRem = rem + altRem;
-    if (
-        (meanRem & UINT64_C( 0x8000000000000000 )) || (! meanRem && (q & 1))
-    ) {
-        rem = altRem;
-    }
-    signRem = signA;
-    if ( rem & UINT64_C( 0x8000000000000000 ) ) {
-        signRem = ! signRem;
-        rem = -rem;
-    }
-    return softfloat_normRoundPackToF64( signRem, expB, rem );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto uiZ;
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f64_rem( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    struct exp16_sig64 normExpSig;
+    uint64_t rem;
+    int_fast16_t expDiff;
+    uint32_t q, recip32;
+    uint_fast64_t q64;
+    uint64_t altRem, meanRem;
+    bool signRem;
+    uint_fast64_t uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    expB = expF64UI( uiB );
+    sigB = fracF64UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN;
+        goto invalid;
+    }
+    if ( expB == 0x7FF ) {
+        if ( sigB ) goto propagateNaN;
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA < expB - 1 ) return a;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expB ) {
+        if ( ! sigB ) goto invalid;
+        normExpSig = softfloat_normSubnormalF64Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    rem = sigA | UINT64_C( 0x0010000000000000 );
+    sigB |= UINT64_C( 0x0010000000000000 );
+    expDiff = expA - expB;
+    if ( expDiff < 1 ) {
+        if ( expDiff < -1 ) return a;
+        sigB <<= 9;
+        if ( expDiff ) {
+            rem <<= 8;
+            q = 0;
+        } else {
+            rem <<= 9;
+            q = (sigB <= rem);
+            if ( q ) rem -= sigB;
+        }
+    } else {
+        recip32 = softfloat_approxRecip32_1( sigB>>21 );
+        /*--------------------------------------------------------------------
+        | Changing the shift of `rem' here requires also changing the initial
+        | subtraction from `expDiff'.
+        *--------------------------------------------------------------------*/
+        rem <<= 9;
+        expDiff -= 30;
+        /*--------------------------------------------------------------------
+        | The scale of `sigB' affects how many bits are obtained during each
+        | cycle of the loop.  Currently this is 29 bits per loop iteration,
+        | the maximum possible.
+        *--------------------------------------------------------------------*/
+        sigB <<= 9;
+        for (;;) {
+            q64 = (uint32_t) (rem>>32) * (uint_fast64_t) recip32;
+            if ( expDiff < 0 ) break;
+            q = (q64 + 0x80000000)>>32;
+#ifdef SOFTFLOAT_FAST_INT64
+            rem <<= 29;
+#else
+            rem = (uint_fast64_t) (uint32_t) (rem>>3)<<32;
+#endif
+            rem -= q * (uint64_t) sigB;
+            if ( rem & UINT64_C( 0x8000000000000000 ) ) rem += sigB;
+            expDiff -= 29;
+        }
+        /*--------------------------------------------------------------------
+        | (`expDiff' cannot be less than -29 here.)
+        *--------------------------------------------------------------------*/
+        q = (uint32_t) (q64>>32)>>(~expDiff & 31);
+        rem = (rem<<(expDiff + 30)) - q * (uint64_t) sigB;
+        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
+            altRem = rem + sigB;
+            goto selectRem;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    do {
+        altRem = rem;
+        ++q;
+        rem -= sigB;
+    } while ( ! (rem & UINT64_C( 0x8000000000000000 )) );
+ selectRem:
+    meanRem = rem + altRem;
+    if (
+        (meanRem & UINT64_C( 0x8000000000000000 )) || (! meanRem && (q & 1))
+    ) {
+        rem = altRem;
+    }
+    signRem = signA;
+    if ( rem & UINT64_C( 0x8000000000000000 ) ) {
+        signRem = ! signRem;
+        rem = -rem;
+    }
+    return softfloat_normRoundPackToF64( signRem, expB, rem );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    goto uiZ;
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF64UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_roundToInt.c b/softfloat/source/f64_roundToInt.c
index 54e7b05..c5f08ae 100644
--- a/softfloat/source/f64_roundToInt.c
+++ b/softfloat/source/f64_roundToInt.c
@@ -1,120 +1,120 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    int_fast16_t exp;
-    uint_fast64_t uiZ, lastBitMask, roundBitsMask;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp <= 0x3FE ) {
-        if ( !(uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) return a;
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-        uiZ = uiA & packToF64UI( 1, 0, 0 );
-        switch ( roundingMode ) {
-         case softfloat_round_near_even:
-            if ( !fracF64UI( uiA ) ) break;
-         case softfloat_round_near_maxMag:
-            if ( exp == 0x3FE ) uiZ |= packToF64UI( 0, 0x3FF, 0 );
-            break;
-         case softfloat_round_min:
-            if ( uiZ ) uiZ = packToF64UI( 1, 0x3FF, 0 );
-            break;
-         case softfloat_round_max:
-            if ( !uiZ ) uiZ = packToF64UI( 0, 0x3FF, 0 );
-            break;
-#ifdef SOFTFLOAT_ROUND_ODD
-         case softfloat_round_odd:
-            uiZ |= packToF64UI( 0, 0x3FF, 0 );
-            break;
-#endif
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x433 <= exp ) {
-        if ( (exp == 0x7FF) && fracF64UI( uiA ) ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
-            goto uiZ;
-        }
-        return a;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ = uiA;
-    lastBitMask = (uint_fast64_t) 1<<(0x433 - exp);
-    roundBitsMask = lastBitMask - 1;
-    if ( roundingMode == softfloat_round_near_maxMag ) {
-        uiZ += lastBitMask>>1;
-    } else if ( roundingMode == softfloat_round_near_even ) {
-        uiZ += lastBitMask>>1;
-        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
-    } else if (
-        roundingMode
-            == (signF64UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
-    ) {
-        uiZ += roundBitsMask;
-    }
-    uiZ &= ~roundBitsMask;
-    if ( uiZ != uiA ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f64_roundToInt( float64_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    int_fast16_t exp;
+    uint_fast64_t uiZ, lastBitMask, roundBitsMask;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp <= 0x3FE ) {
+        if ( !(uiA & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) return a;
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+        uiZ = uiA & packToF64UI( 1, 0, 0 );
+        switch ( roundingMode ) {
+         case softfloat_round_near_even:
+            if ( !fracF64UI( uiA ) ) break;
+         case softfloat_round_near_maxMag:
+            if ( exp == 0x3FE ) uiZ |= packToF64UI( 0, 0x3FF, 0 );
+            break;
+         case softfloat_round_min:
+            if ( uiZ ) uiZ = packToF64UI( 1, 0x3FF, 0 );
+            break;
+         case softfloat_round_max:
+            if ( !uiZ ) uiZ = packToF64UI( 0, 0x3FF, 0 );
+            break;
+#ifdef SOFTFLOAT_ROUND_ODD
+         case softfloat_round_odd:
+            uiZ |= packToF64UI( 0, 0x3FF, 0 );
+            break;
+#endif
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x433 <= exp ) {
+        if ( (exp == 0x7FF) && fracF64UI( uiA ) ) {
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            goto uiZ;
+        }
+        return a;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ = uiA;
+    lastBitMask = (uint_fast64_t) 1<<(0x433 - exp);
+    roundBitsMask = lastBitMask - 1;
+    if ( roundingMode == softfloat_round_near_maxMag ) {
+        uiZ += lastBitMask>>1;
+    } else if ( roundingMode == softfloat_round_near_even ) {
+        uiZ += lastBitMask>>1;
+        if ( !(uiZ & roundBitsMask) ) uiZ &= ~lastBitMask;
+    } else if (
+        roundingMode
+            == (signF64UI( uiZ ) ? softfloat_round_min : softfloat_round_max)
+    ) {
+        uiZ += roundBitsMask;
+    }
+    uiZ &= ~roundBitsMask;
+    if ( uiZ != uiA ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) uiZ |= lastBitMask;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_sqrt.c b/softfloat/source/f64_sqrt.c
index f9f226b..f12acdb 100644
--- a/softfloat/source/f64_sqrt.c
+++ b/softfloat/source/f64_sqrt.c
@@ -1,133 +1,133 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t f64_sqrt( float64_t a )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA, uiZ;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-    uint32_t sig32A, recipSqrt32, sig32Z;
-    uint_fast64_t rem;
-    uint32_t q;
-    uint_fast64_t sigZ, shiftedSigZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA ) {
-            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
-            goto uiZ;
-        }
-        if ( ! signA ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signA ) {
-        if ( ! (expA | sigA) ) return a;
-        goto invalid;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) return a;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    | (`sig32Z' is guaranteed to be a lower bound on the square root of
-    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
-    | `sigA'.)
-    *------------------------------------------------------------------------*/
-    expZ = ((expA - 0x3FF)>>1) + 0x3FE;
-    expA &= 1;
-    sigA |= UINT64_C( 0x0010000000000000 );
-    sig32A = sigA>>21;
-    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
-    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
-    if ( expA ) {
-        sigA <<= 8;
-        sig32Z >>= 1;
-    } else {
-        sigA <<= 9;
-    }
-    rem = sigA - (uint_fast64_t) sig32Z * sig32Z;
-    q = ((uint32_t) (rem>>2) * (uint_fast64_t) recipSqrt32)>>32;
-    sigZ = ((uint_fast64_t) sig32Z<<32 | 1<<5) + ((uint_fast64_t) q<<3);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (sigZ & 0x1FF) < 0x22 ) {
-        sigZ &= ~(uint_fast64_t) 0x3F;
-        shiftedSigZ = sigZ>>6;
-        rem = (sigA<<52) - shiftedSigZ * shiftedSigZ;
-        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
-            --sigZ;
-        } else {
-            if ( rem ) sigZ |= 1;
-        }
-    }
-    return softfloat_roundPackToF64( 0, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t f64_sqrt( float64_t a )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    int_fast16_t expA;
+    uint_fast64_t sigA, uiZ;
+    struct exp16_sig64 normExpSig;
+    int_fast16_t expZ;
+    uint32_t sig32A, recipSqrt32, sig32Z;
+    uint_fast64_t rem;
+    uint32_t q;
+    uint_fast64_t sigZ, shiftedSigZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA ) {
+            uiZ = softfloat_propagateNaNF64UI( uiA, 0 );
+            goto uiZ;
+        }
+        if ( ! signA ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signA ) {
+        if ( ! (expA | sigA) ) return a;
+        goto invalid;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) return a;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    | (`sig32Z' is guaranteed to be a lower bound on the square root of
+    | `sig32A', which makes `sig32Z' also a lower bound on the square root of
+    | `sigA'.)
+    *------------------------------------------------------------------------*/
+    expZ = ((expA - 0x3FF)>>1) + 0x3FE;
+    expA &= 1;
+    sigA |= UINT64_C( 0x0010000000000000 );
+    sig32A = sigA>>21;
+    recipSqrt32 = softfloat_approxRecipSqrt32_1( expA, sig32A );
+    sig32Z = ((uint_fast64_t) sig32A * recipSqrt32)>>32;
+    if ( expA ) {
+        sigA <<= 8;
+        sig32Z >>= 1;
+    } else {
+        sigA <<= 9;
+    }
+    rem = sigA - (uint_fast64_t) sig32Z * sig32Z;
+    q = ((uint32_t) (rem>>2) * (uint_fast64_t) recipSqrt32)>>32;
+    sigZ = ((uint_fast64_t) sig32Z<<32 | 1<<5) + ((uint_fast64_t) q<<3);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (sigZ & 0x1FF) < 0x22 ) {
+        sigZ &= ~(uint_fast64_t) 0x3F;
+        shiftedSigZ = sigZ>>6;
+        rem = (sigA<<52) - shiftedSigZ * shiftedSigZ;
+        if ( rem & UINT64_C( 0x8000000000000000 ) ) {
+            --sigZ;
+        } else {
+            if ( rem ) sigZ |= 1;
+        }
+    }
+    return softfloat_roundPackToF64( 0, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF64UI;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_sub.c b/softfloat/source/f64_sub.c
index b5ccb88..74158be 100644
--- a/softfloat/source/f64_sub.c
+++ b/softfloat/source/f64_sub.c
@@ -1,74 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t f64_sub( float64_t a, float64_t b )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool signA;
-    union ui64_f64 uB;
-    uint_fast64_t uiB;
-    bool signB;
-#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
-    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
-#endif
-
-    uA.f = a;
-    uiA = uA.ui;
-    signA = signF64UI( uiA );
-    uB.f = b;
-    uiB = uB.ui;
-    signB = signF64UI( uiB );
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-    if ( signA == signB ) {
-        return softfloat_subMagsF64( uiA, uiB, signA );
-    } else {
-        return softfloat_addMagsF64( uiA, uiB, signA );
-    }
-#else
-    magsFuncPtr =
-        (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64;
-    return (*magsFuncPtr)( uiA, uiB, signA );
-#endif
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t f64_sub( float64_t a, float64_t b )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool signA;
+    union ui64_f64 uB;
+    uint_fast64_t uiB;
+    bool signB;
+#if ! defined INLINE_LEVEL || (INLINE_LEVEL < 2)
+    float64_t (*magsFuncPtr)( uint_fast64_t, uint_fast64_t, bool );
+#endif
+
+    uA.f = a;
+    uiA = uA.ui;
+    signA = signF64UI( uiA );
+    uB.f = b;
+    uiB = uB.ui;
+    signB = signF64UI( uiB );
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+    if ( signA == signB ) {
+        return softfloat_subMagsF64( uiA, uiB, signA );
+    } else {
+        return softfloat_addMagsF64( uiA, uiB, signA );
+    }
+#else
+    magsFuncPtr =
+        (signA == signB) ? softfloat_subMagsF64 : softfloat_addMagsF64;
+    return (*magsFuncPtr)( uiA, uiB, signA );
+#endif
+
+}
+
diff --git a/softfloat/source/f64_to_extF80.c b/softfloat/source/f64_to_extF80.c
index 2799d9b..553ebd0 100644
--- a/softfloat/source/f64_to_extF80.c
+++ b/softfloat/source/f64_to_extF80.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t f64_to_extF80( float64_t a )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    struct exp16_sig64 normExpSig;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
-            uiZ64 = uiZ.v64;
-            uiZ0  = uiZ.v0;
-        } else {
-            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-            uiZ0  = UINT64_C( 0x8000000000000000 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 );
-    uiZ0  = (frac | UINT64_C( 0x0010000000000000 ))<<11;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t f64_to_extF80( float64_t a )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    struct exp16_sig64 normExpSig;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToExtF80UI( &commonNaN );
+            uiZ64 = uiZ.v64;
+            uiZ0  = uiZ.v0;
+        } else {
+            uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+            uiZ0  = UINT64_C( 0x8000000000000000 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 );
+    uiZ0  = (frac | UINT64_C( 0x0010000000000000 ))<<11;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_to_extF80M.c b/softfloat/source/f64_to_extF80M.c
index a2e67e4..d258bdc 100644
--- a/softfloat/source/f64_to_extF80M.c
+++ b/softfloat/source/f64_to_extF80M.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = f64_to_extF80( a );
-
-}
-
-#else
-
-void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    union ui64_f64 uA;
-    uint64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint64_t frac;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ64;
-    uint64_t uiZ0;
-    struct exp16_sig64 normExpSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zSPtr = (struct extFloat80M *) zPtr;
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
-            return;
-        }
-        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
-        uiZ0  = UINT64_C( 0x8000000000000000 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ64 = packToExtF80UI64( sign, 0 );
-            uiZ0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( frac );
-        exp = normExpSig.exp;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 );
-    uiZ0  = UINT64_C( 0x8000000000000000 ) | frac<<11;
- uiZ:
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif  = uiZ0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = f64_to_extF80( a );
+
+}
+
+#else
+
+void f64_to_extF80M( float64_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    union ui64_f64 uA;
+    uint64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint64_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ64;
+    uint64_t uiZ0;
+    struct exp16_sig64 normExpSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zSPtr = (struct extFloat80M *) zPtr;
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToExtF80M( &commonNaN, zSPtr );
+            return;
+        }
+        uiZ64 = packToExtF80UI64( sign, 0x7FFF );
+        uiZ0  = UINT64_C( 0x8000000000000000 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ64 = packToExtF80UI64( sign, 0 );
+            uiZ0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( frac );
+        exp = normExpSig.exp;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiZ64 = packToExtF80UI64( sign, exp + 0x3C00 );
+    uiZ0  = UINT64_C( 0x8000000000000000 ) | frac<<11;
+ uiZ:
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif  = uiZ0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f64_to_f128.c b/softfloat/source/f64_to_f128.c
index 60af3b0..8f03f2f 100644
--- a/softfloat/source/f64_to_f128.c
+++ b/softfloat/source/f64_to_f128.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t f64_to_f128( float64_t a )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t frac;
-    struct commonNaN commonNaN;
-    struct uint128 uiZ;
-    struct exp16_sig64 normExpSig;
-    struct uint128 frac128;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
-        } else {
-            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
-            uiZ.v0  = 0;
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ.v64 = packToF128UI64( sign, 0, 0 );
-            uiZ.v0  = 0;
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac128 = softfloat_shortShiftLeft128( 0, frac, 60 );
-    uiZ.v64 = packToF128UI64( sign, exp + 0x3C00, frac128.v64 );
-    uiZ.v0  = frac128.v0;
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t f64_to_f128( float64_t a )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t frac;
+    struct commonNaN commonNaN;
+    struct uint128 uiZ;
+    struct exp16_sig64 normExpSig;
+    struct uint128 frac128;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF128UI( &commonNaN );
+        } else {
+            uiZ.v64 = packToF128UI64( sign, 0x7FFF, 0 );
+            uiZ.v0  = 0;
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ.v64 = packToF128UI64( sign, 0, 0 );
+            uiZ.v0  = 0;
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac128 = softfloat_shortShiftLeft128( 0, frac, 60 );
+    uiZ.v64 = packToF128UI64( sign, exp + 0x3C00, frac128.v64 );
+    uiZ.v0  = frac128.v0;
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_to_f128M.c b/softfloat/source/f64_to_f128M.c
index fbc4515..e4a862c 100644
--- a/softfloat/source/f64_to_f128M.c
+++ b/softfloat/source/f64_to_f128M.c
@@ -1,117 +1,117 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void f64_to_f128M( float64_t a, float128_t *zPtr )
-{
-
-    *zPtr = f64_to_f128( a );
-
-}
-
-#else
-
-void f64_to_f128M( float64_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr;
-    union ui64_f64 uA;
-    uint64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint64_t frac;
-    struct commonNaN commonNaN;
-    uint32_t uiZ96;
-    struct exp16_sig64 normExpSig;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr = (uint32_t *) zPtr;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr[indexWord( 4, 0 )] = 0;
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
-            return;
-        }
-        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! exp ) {
-        if ( ! frac ) {
-            uiZ96 = packToF128UI96( sign, 0, 0 );
-            goto uiZ;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( frac );
-        exp = normExpSig.exp - 1;
-        frac = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    zWPtr[indexWord( 4, 1 )] = (uint32_t) frac<<28;
-    frac >>= 4;
-    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp + 0x3C00, frac>>32 );
-    zWPtr[indexWord( 4, 2 )] = frac;
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- uiZ:
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void f64_to_f128M( float64_t a, float128_t *zPtr )
+{
+
+    *zPtr = f64_to_f128( a );
+
+}
+
+#else
+
+void f64_to_f128M( float64_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr;
+    union ui64_f64 uA;
+    uint64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint64_t frac;
+    struct commonNaN commonNaN;
+    uint32_t uiZ96;
+    struct exp16_sig64 normExpSig;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr = (uint32_t *) zPtr;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr[indexWord( 4, 0 )] = 0;
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            softfloat_commonNaNToF128M( &commonNaN, zWPtr );
+            return;
+        }
+        uiZ96 = packToF128UI96( sign, 0x7FFF, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! exp ) {
+        if ( ! frac ) {
+            uiZ96 = packToF128UI96( sign, 0, 0 );
+            goto uiZ;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( frac );
+        exp = normExpSig.exp - 1;
+        frac = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    zWPtr[indexWord( 4, 1 )] = (uint32_t) frac<<28;
+    frac >>= 4;
+    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp + 0x3C00, frac>>32 );
+    zWPtr[indexWord( 4, 2 )] = frac;
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ uiZ:
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/f64_to_f16.c b/softfloat/source/f64_to_f16.c
index 121e306..0cc6cc5 100644
--- a/softfloat/source/f64_to_f16.c
+++ b/softfloat/source/f64_to_f16.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t f64_to_f16( float64_t a )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t frac;
-    struct commonNaN commonNaN;
-    uint_fast16_t uiZ, frac16;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
-        } else {
-            uiZ = packToF16UI( sign, 0x1F, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac16 = softfloat_shortShiftRightJam64( frac, 38 );
-    if ( ! (exp | frac16) ) {
-        uiZ = packToF16UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t f64_to_f16( float64_t a )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t frac;
+    struct commonNaN commonNaN;
+    uint_fast16_t uiZ, frac16;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF16UI( &commonNaN );
+        } else {
+            uiZ = packToF16UI( sign, 0x1F, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac16 = softfloat_shortShiftRightJam64( frac, 38 );
+    if ( ! (exp | frac16) ) {
+        uiZ = packToF16UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    return softfloat_roundPackToF16( sign, exp - 0x3F1, frac16 | 0x4000 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_to_f32.c b/softfloat/source/f64_to_f32.c
index a181065..6074bb8 100644
--- a/softfloat/source/f64_to_f32.c
+++ b/softfloat/source/f64_to_f32.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t f64_to_f32( float64_t a )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t frac;
-    struct commonNaN commonNaN;
-    uint_fast32_t uiZ, frac32;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    frac = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp == 0x7FF ) {
-        if ( frac ) {
-            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
-            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
-        } else {
-            uiZ = packToF32UI( sign, 0xFF, 0 );
-        }
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    frac32 = softfloat_shortShiftRightJam64( frac, 22 );
-    if ( ! (exp | frac32) ) {
-        uiZ = packToF32UI( sign, 0, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t f64_to_f32( float64_t a )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t frac;
+    struct commonNaN commonNaN;
+    uint_fast32_t uiZ, frac32;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    frac = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp == 0x7FF ) {
+        if ( frac ) {
+            softfloat_f64UIToCommonNaN( uiA, &commonNaN );
+            uiZ = softfloat_commonNaNToF32UI( &commonNaN );
+        } else {
+            uiZ = packToF32UI( sign, 0xFF, 0 );
+        }
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    frac32 = softfloat_shortShiftRightJam64( frac, 22 );
+    if ( ! (exp | frac32) ) {
+        uiZ = packToF32UI( sign, 0, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    return softfloat_roundPackToF32( sign, exp - 0x381, frac32 | 0x40000000 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/f64_to_i32.c b/softfloat/source/f64_to_i32.c
index 8d9785b..2cf2603 100644
--- a/softfloat/source/f64_to_i32.c
+++ b/softfloat/source/f64_to_i32.c
@@ -1,82 +1,82 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    sig  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
-    if ( (exp == 0x7FF) && sig ) {
-#if (i32_fromNaN == i32_fromPosOverflow)
-        sign = 0;
-#elif (i32_fromNaN == i32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return i32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
-    shiftDist = 0x427 - exp;
-    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToI32( sign, sig, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f64_to_i32( float64_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    sig  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (i32_fromNaN != i32_fromPosOverflow) || (i32_fromNaN != i32_fromNegOverflow)
+    if ( (exp == 0x7FF) && sig ) {
+#if (i32_fromNaN == i32_fromPosOverflow)
+        sign = 0;
+#elif (i32_fromNaN == i32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return i32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
+    shiftDist = 0x427 - exp;
+    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
+    return softfloat_roundToI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f64_to_i32_r_minMag.c b/softfloat/source/f64_to_i32_r_minMag.c
index 8b7a91f..8cccb8e 100644
--- a/softfloat/source/f64_to_i32_r_minMag.c
+++ b/softfloat/source/f64_to_i32_r_minMag.c
@@ -1,96 +1,96 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    int_fast32_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF64UI( uiA );
-    sig = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x433 - exp;
-    if ( 53 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF64UI( uiA );
-    if ( shiftDist < 22 ) {
-        if (
-            sign && (exp == 0x41E) && (sig < UINT64_C( 0x0000000000200000 ))
-        ) {
-            if ( exact && sig ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return -0x7FFFFFFF - 1;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FF) && sig ? i32_fromNaN
-                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig |= UINT64_C( 0x0010000000000000 );
-    absZ = sig>>shiftDist;
-    if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t f64_to_i32_r_minMag( float64_t a, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    int_fast32_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF64UI( uiA );
+    sig = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x433 - exp;
+    if ( 53 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF64UI( uiA );
+    if ( shiftDist < 22 ) {
+        if (
+            sign && (exp == 0x41E) && (sig < UINT64_C( 0x0000000000200000 ))
+        ) {
+            if ( exact && sig ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return -0x7FFFFFFF - 1;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FF) && sig ? i32_fromNaN
+                : sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig |= UINT64_C( 0x0010000000000000 );
+    absZ = sig>>shiftDist;
+    if ( exact && ((uint_fast64_t) (uint_fast32_t) absZ<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f64_to_i64.c b/softfloat/source/f64_to_i64.c
index 7199643..0acf6c2 100644
--- a/softfloat/source/f64_to_i64.c
+++ b/softfloat/source/f64_to_i64.c
@@ -1,103 +1,103 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-#ifdef SOFTFLOAT_FAST_INT64
-    struct uint64_extra sigExtra;
-#else
-    uint32_t extSig[3];
-#endif
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    sig  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
-    shiftDist = 0x433 - exp;
-#ifdef SOFTFLOAT_FAST_INT64
-    if ( shiftDist <= 0 ) {
-        if ( shiftDist < -11 ) goto invalid;
-        sigExtra.v = sig<<-shiftDist;
-        sigExtra.extra = 0;
-    } else {
-        sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
-    }
-    return
-        softfloat_roundToI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
-#else
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist <= 0 ) {
-        if ( shiftDist < -11 ) goto invalid;
-        sig <<= -shiftDist;
-        extSig[indexWord( 3, 2 )] = sig>>32;
-        extSig[indexWord( 3, 1 )] = sig;
-    } else {
-        extSig[indexWord( 3, 2 )] = sig>>32;
-        extSig[indexWord( 3, 1 )] = sig;
-        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    }
-    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN
-            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f64_to_i64( float64_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+#ifdef SOFTFLOAT_FAST_INT64
+    struct uint64_extra sigExtra;
+#else
+    uint32_t extSig[3];
+#endif
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    sig  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
+    shiftDist = 0x433 - exp;
+#ifdef SOFTFLOAT_FAST_INT64
+    if ( shiftDist <= 0 ) {
+        if ( shiftDist < -11 ) goto invalid;
+        sigExtra.v = sig<<-shiftDist;
+        sigExtra.extra = 0;
+    } else {
+        sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+    }
+    return
+        softfloat_roundToI64(
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+#else
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist <= 0 ) {
+        if ( shiftDist < -11 ) goto invalid;
+        sig <<= -shiftDist;
+        extSig[indexWord( 3, 2 )] = sig>>32;
+        extSig[indexWord( 3, 1 )] = sig;
+    } else {
+        extSig[indexWord( 3, 2 )] = sig>>32;
+        extSig[indexWord( 3, 1 )] = sig;
+        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    }
+    return softfloat_roundMToI64( sign, extSig, roundingMode, exact );
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FF) && fracF64UI( uiA ) ? i64_fromNaN
+            : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/f64_to_i64_r_minMag.c b/softfloat/source/f64_to_i64_r_minMag.c
index 56c6a10..4fcc52c 100644
--- a/softfloat/source/f64_to_i64_r_minMag.c
+++ b/softfloat/source/f64_to_i64_r_minMag.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-    int_fast64_t absZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    sig  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x433 - exp;
-    if ( shiftDist <= 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( shiftDist < -10 ) {
-            if ( uiA == packToF64UI( 1, 0x43E, 0 ) ) {
-                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
-            }
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            return
-                (exp == 0x7FF) && sig ? i64_fromNaN
-                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig |= UINT64_C( 0x0010000000000000 );
-        absZ = sig<<-shiftDist;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( 53 <= shiftDist ) {
-            if ( exact && (exp | sig) ) {
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-            }
-            return 0;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig |= UINT64_C( 0x0010000000000000 );
-        absZ = sig>>shiftDist;
-        if ( exact && (absZ<<shiftDist != sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return sign ? -absZ : absZ;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t f64_to_i64_r_minMag( float64_t a, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+    int_fast64_t absZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    sig  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x433 - exp;
+    if ( shiftDist <= 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( shiftDist < -10 ) {
+            if ( uiA == packToF64UI( 1, 0x43E, 0 ) ) {
+                return -INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1;
+            }
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            return
+                (exp == 0x7FF) && sig ? i64_fromNaN
+                    : sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig |= UINT64_C( 0x0010000000000000 );
+        absZ = sig<<-shiftDist;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( 53 <= shiftDist ) {
+            if ( exact && (exp | sig) ) {
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+            }
+            return 0;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig |= UINT64_C( 0x0010000000000000 );
+        absZ = sig>>shiftDist;
+        if ( exact && (absZ<<shiftDist != sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return sign ? -absZ : absZ;
+
+}
+
diff --git a/softfloat/source/f64_to_ui32.c b/softfloat/source/f64_to_ui32.c
index 9d21146..4326922 100644
--- a/softfloat/source/f64_to_ui32.c
+++ b/softfloat/source/f64_to_ui32.c
@@ -1,82 +1,82 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    sig  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
-    if ( (exp == 0x7FF) && sig ) {
-#if (ui32_fromNaN == ui32_fromPosOverflow)
-        sign = 0;
-#elif (ui32_fromNaN == ui32_fromNegOverflow)
-        sign = 1;
-#else
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return ui32_fromNaN;
-#endif
-    }
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
-    shiftDist = 0x427 - exp;
-    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
-    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f64_to_ui32( float64_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    sig  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+#if (ui32_fromNaN != ui32_fromPosOverflow) || (ui32_fromNaN != ui32_fromNegOverflow)
+    if ( (exp == 0x7FF) && sig ) {
+#if (ui32_fromNaN == ui32_fromPosOverflow)
+        sign = 0;
+#elif (ui32_fromNaN == ui32_fromNegOverflow)
+        sign = 1;
+#else
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return ui32_fromNaN;
+#endif
+    }
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
+    shiftDist = 0x427 - exp;
+    if ( 0 < shiftDist ) sig = softfloat_shiftRightJam64( sig, shiftDist );
+    return softfloat_roundToUI32( sign, sig, roundingMode, exact );
+
+}
+
diff --git a/softfloat/source/f64_to_ui32_r_minMag.c b/softfloat/source/f64_to_ui32_r_minMag.c
index 6e3d14e..01758dc 100644
--- a/softfloat/source/f64_to_ui32_r_minMag.c
+++ b/softfloat/source/f64_to_ui32_r_minMag.c
@@ -1,88 +1,88 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    uint_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF64UI( uiA );
-    sig = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x433 - exp;
-    if ( 53 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF64UI( uiA );
-    if ( sign || (shiftDist < 21) ) {
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        return
-            (exp == 0x7FF) && sig ? ui32_fromNaN
-                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig |= UINT64_C( 0x0010000000000000 );
-    z = sig>>shiftDist;
-    if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t f64_to_ui32_r_minMag( float64_t a, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    uint_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF64UI( uiA );
+    sig = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x433 - exp;
+    if ( 53 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF64UI( uiA );
+    if ( sign || (shiftDist < 21) ) {
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        return
+            (exp == 0x7FF) && sig ? ui32_fromNaN
+                : sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig |= UINT64_C( 0x0010000000000000 );
+    z = sig>>shiftDist;
+    if ( exact && ((uint_fast64_t) z<<shiftDist != sig) ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/f64_to_ui64.c b/softfloat/source/f64_to_ui64.c
index 292e47a..e7fb8f6 100644
--- a/softfloat/source/f64_to_ui64.c
+++ b/softfloat/source/f64_to_ui64.c
@@ -1,103 +1,103 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    bool sign;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-#ifdef SOFTFLOAT_FAST_INT64
-    struct uint64_extra sigExtra;
-#else
-    uint32_t extSig[3];
-#endif
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    sign = signF64UI( uiA );
-    exp  = expF64UI( uiA );
-    sig  = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
-    shiftDist = 0x433 - exp;
-#ifdef SOFTFLOAT_FAST_INT64
-    if ( shiftDist <= 0 ) {
-        if ( shiftDist < -11 ) goto invalid;
-        sigExtra.v = sig<<-shiftDist;
-        sigExtra.extra = 0;
-    } else {
-        sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
-    }
-    return
-        softfloat_roundToUI64(
-            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
-#else
-    extSig[indexWord( 3, 0 )] = 0;
-    if ( shiftDist <= 0 ) {
-        if ( shiftDist < -11 ) goto invalid;
-        sig <<= -shiftDist;
-        extSig[indexWord( 3, 2 )] = sig>>32;
-        extSig[indexWord( 3, 1 )] = sig;
-    } else {
-        extSig[indexWord( 3, 2 )] = sig>>32;
-        extSig[indexWord( 3, 1 )] = sig;
-        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
-    }
-    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
-#endif
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN
-            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f64_to_ui64( float64_t a, uint_fast8_t roundingMode, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    bool sign;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+#ifdef SOFTFLOAT_FAST_INT64
+    struct uint64_extra sigExtra;
+#else
+    uint32_t extSig[3];
+#endif
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    sign = signF64UI( uiA );
+    exp  = expF64UI( uiA );
+    sig  = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( exp ) sig |= UINT64_C( 0x0010000000000000 );
+    shiftDist = 0x433 - exp;
+#ifdef SOFTFLOAT_FAST_INT64
+    if ( shiftDist <= 0 ) {
+        if ( shiftDist < -11 ) goto invalid;
+        sigExtra.v = sig<<-shiftDist;
+        sigExtra.extra = 0;
+    } else {
+        sigExtra = softfloat_shiftRightJam64Extra( sig, 0, shiftDist );
+    }
+    return
+        softfloat_roundToUI64(
+            sign, sigExtra.v, sigExtra.extra, roundingMode, exact );
+#else
+    extSig[indexWord( 3, 0 )] = 0;
+    if ( shiftDist <= 0 ) {
+        if ( shiftDist < -11 ) goto invalid;
+        sig <<= -shiftDist;
+        extSig[indexWord( 3, 2 )] = sig>>32;
+        extSig[indexWord( 3, 1 )] = sig;
+    } else {
+        extSig[indexWord( 3, 2 )] = sig>>32;
+        extSig[indexWord( 3, 1 )] = sig;
+        softfloat_shiftRightJam96M( extSig, shiftDist, extSig );
+    }
+    return softfloat_roundMToUI64( sign, extSig, roundingMode, exact );
+#endif
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FF) && fracF64UI( uiA ) ? ui64_fromNaN
+            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/f64_to_ui64_r_minMag.c b/softfloat/source/f64_to_ui64_r_minMag.c
index 87eb0d0..e1d81a0 100644
--- a/softfloat/source/f64_to_ui64_r_minMag.c
+++ b/softfloat/source/f64_to_ui64_r_minMag.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
-{
-    union ui64_f64 uA;
-    uint_fast64_t uiA;
-    int_fast16_t exp;
-    uint_fast64_t sig;
-    int_fast16_t shiftDist;
-    bool sign;
-    uint_fast64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uA.f = a;
-    uiA = uA.ui;
-    exp = expF64UI( uiA );
-    sig = fracF64UI( uiA );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 0x433 - exp;
-    if ( 53 <= shiftDist ) {
-        if ( exact && (exp | sig) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-        return 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sign = signF64UI( uiA );
-    if ( sign ) goto invalid;
-    if ( shiftDist <= 0 ) {
-        if ( shiftDist < -11 ) goto invalid;
-        z = (sig | UINT64_C( 0x0010000000000000 ))<<-shiftDist;
-    } else {
-        sig |= UINT64_C( 0x0010000000000000 );
-        z = sig>>shiftDist;
-        if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
-            softfloat_exceptionFlags |= softfloat_flag_inexact;
-        }
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return
-        (exp == 0x7FF) && sig ? ui64_fromNaN
-            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t f64_to_ui64_r_minMag( float64_t a, bool exact )
+{
+    union ui64_f64 uA;
+    uint_fast64_t uiA;
+    int_fast16_t exp;
+    uint_fast64_t sig;
+    int_fast16_t shiftDist;
+    bool sign;
+    uint_fast64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uA.f = a;
+    uiA = uA.ui;
+    exp = expF64UI( uiA );
+    sig = fracF64UI( uiA );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 0x433 - exp;
+    if ( 53 <= shiftDist ) {
+        if ( exact && (exp | sig) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+        return 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sign = signF64UI( uiA );
+    if ( sign ) goto invalid;
+    if ( shiftDist <= 0 ) {
+        if ( shiftDist < -11 ) goto invalid;
+        z = (sig | UINT64_C( 0x0010000000000000 ))<<-shiftDist;
+    } else {
+        sig |= UINT64_C( 0x0010000000000000 );
+        z = sig>>shiftDist;
+        if ( exact && (uint64_t) (sig<<(-shiftDist & 63)) ) {
+            softfloat_exceptionFlags |= softfloat_flag_inexact;
+        }
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return
+        (exp == 0x7FF) && sig ? ui64_fromNaN
+            : sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/i32_to_extF80.c b/softfloat/source/i32_to_extF80.c
index 8036fa9..fd91cf0 100644
--- a/softfloat/source/i32_to_extF80.c
+++ b/softfloat/source/i32_to_extF80.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t i32_to_extF80( int32_t a )
-{
-    uint_fast16_t uiZ64;
-    uint_fast32_t absA;
-    bool sign;
-    int_fast8_t shiftDist;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    uiZ64 = 0;
-    absA = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-        shiftDist = softfloat_countLeadingZeros32( absA );
-        uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );
-        absA <<= shiftDist;
-    }
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif = (uint_fast64_t) absA<<32;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t i32_to_extF80( int32_t a )
+{
+    uint_fast16_t uiZ64;
+    uint_fast32_t absA;
+    bool sign;
+    int_fast8_t shiftDist;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    uiZ64 = 0;
+    absA = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
+        shiftDist = softfloat_countLeadingZeros32( absA );
+        uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );
+        absA <<= shiftDist;
+    }
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif = (uint_fast64_t) absA<<32;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/i32_to_extF80M.c b/softfloat/source/i32_to_extF80M.c
index 6d5431c..d12e3a8 100644
--- a/softfloat/source/i32_to_extF80M.c
+++ b/softfloat/source/i32_to_extF80M.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = i32_to_extF80( a );
-
-}
-
-#else
-
-void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiZ64;
-    uint64_t sigZ;
-    bool sign;
-    uint32_t absA;
-    int_fast8_t shiftDist;
-
-    zSPtr = (struct extFloat80M *) zPtr;
-    uiZ64 = 0;
-    sigZ = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint32_t) a : (uint32_t) a;
-        shiftDist = softfloat_countLeadingZeros32( absA );
-        uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );
-        sigZ = (uint64_t) (absA<<shiftDist)<<32;
-    }
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = sigZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = i32_to_extF80( a );
+
+}
+
+#else
+
+void i32_to_extF80M( int32_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiZ64;
+    uint64_t sigZ;
+    bool sign;
+    uint32_t absA;
+    int_fast8_t shiftDist;
+
+    zSPtr = (struct extFloat80M *) zPtr;
+    uiZ64 = 0;
+    sigZ = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint32_t) a : (uint32_t) a;
+        shiftDist = softfloat_countLeadingZeros32( absA );
+        uiZ64 = packToExtF80UI64( sign, 0x401E - shiftDist );
+        sigZ = (uint64_t) (absA<<shiftDist)<<32;
+    }
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = sigZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/i32_to_f128.c b/softfloat/source/i32_to_f128.c
index a7d55cb..75575bd 100644
--- a/softfloat/source/i32_to_f128.c
+++ b/softfloat/source/i32_to_f128.c
@@ -1,64 +1,64 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t i32_to_f128( int32_t a )
-{
-    uint_fast64_t uiZ64;
-    bool sign;
-    uint_fast32_t absA;
-    int_fast8_t shiftDist;
-    union ui128_f128 uZ;
-
-    uiZ64 = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-        shiftDist = softfloat_countLeadingZeros32( absA ) + 17;
-        uiZ64 =
-            packToF128UI64(
-                sign, 0x402E - shiftDist, (uint_fast64_t) absA<<shiftDist );
-    }
-    uZ.ui.v64 = uiZ64;
-    uZ.ui.v0  = 0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t i32_to_f128( int32_t a )
+{
+    uint_fast64_t uiZ64;
+    bool sign;
+    uint_fast32_t absA;
+    int_fast8_t shiftDist;
+    union ui128_f128 uZ;
+
+    uiZ64 = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
+        shiftDist = softfloat_countLeadingZeros32( absA ) + 17;
+        uiZ64 =
+            packToF128UI64(
+                sign, 0x402E - shiftDist, (uint_fast64_t) absA<<shiftDist );
+    }
+    uZ.ui.v64 = uiZ64;
+    uZ.ui.v0  = 0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/i32_to_f128M.c b/softfloat/source/i32_to_f128M.c
index beb3c10..8b3ce4b 100644
--- a/softfloat/source/i32_to_f128M.c
+++ b/softfloat/source/i32_to_f128M.c
@@ -1,81 +1,81 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void i32_to_f128M( int32_t a, float128_t *zPtr )
-{
-
-    *zPtr = i32_to_f128( a );
-
-}
-
-#else
-
-void i32_to_f128M( int32_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr;
-    uint32_t uiZ96, uiZ64;
-    bool sign;
-    uint32_t absA;
-    int_fast8_t shiftDist;
-    uint64_t normAbsA;
-
-    zWPtr = (uint32_t *) zPtr;
-    uiZ96 = 0;
-    uiZ64 = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint32_t) a : (uint32_t) a;
-        shiftDist = softfloat_countLeadingZeros32( absA ) + 17;
-        normAbsA = (uint64_t) absA<<shiftDist;
-        uiZ96 = packToF128UI96( sign, 0x402E - shiftDist, normAbsA>>32 );
-        uiZ64 = normAbsA;
-    }
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = uiZ64;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void i32_to_f128M( int32_t a, float128_t *zPtr )
+{
+
+    *zPtr = i32_to_f128( a );
+
+}
+
+#else
+
+void i32_to_f128M( int32_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr;
+    uint32_t uiZ96, uiZ64;
+    bool sign;
+    uint32_t absA;
+    int_fast8_t shiftDist;
+    uint64_t normAbsA;
+
+    zWPtr = (uint32_t *) zPtr;
+    uiZ96 = 0;
+    uiZ64 = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint32_t) a : (uint32_t) a;
+        shiftDist = softfloat_countLeadingZeros32( absA ) + 17;
+        normAbsA = (uint64_t) absA<<shiftDist;
+        uiZ96 = packToF128UI96( sign, 0x402E - shiftDist, normAbsA>>32 );
+        uiZ64 = normAbsA;
+    }
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = uiZ64;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/i32_to_f16.c b/softfloat/source/i32_to_f16.c
index d311724..14ac588 100644
--- a/softfloat/source/i32_to_f16.c
+++ b/softfloat/source/i32_to_f16.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t i32_to_f16( int32_t a )
-{
-    bool sign;
-    uint_fast32_t absA;
-    int_fast8_t shiftDist;
-    union ui16_f16 u;
-    uint_fast16_t sig;
-
-    sign = (a < 0);
-    absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-    shiftDist = softfloat_countLeadingZeros32( absA ) - 21;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF16UI(
-                    sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 4;
-        sig =
-            (shiftDist < 0)
-                ? absA>>(-shiftDist)
-                      | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
-                : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t i32_to_f16( int32_t a )
+{
+    bool sign;
+    uint_fast32_t absA;
+    int_fast8_t shiftDist;
+    union ui16_f16 u;
+    uint_fast16_t sig;
+
+    sign = (a < 0);
+    absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
+    shiftDist = softfloat_countLeadingZeros32( absA ) - 21;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF16UI(
+                    sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 4;
+        sig =
+            (shiftDist < 0)
+                ? absA>>(-shiftDist)
+                      | ((uint32_t) (absA<<(shiftDist & 31)) != 0)
+                : (uint_fast16_t) absA<<shiftDist;
+        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/i32_to_f32.c b/softfloat/source/i32_to_f32.c
index e6de3e8..4057655 100644
--- a/softfloat/source/i32_to_f32.c
+++ b/softfloat/source/i32_to_f32.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t i32_to_f32( int32_t a )
-{
-    bool sign;
-    union ui32_f32 uZ;
-    uint_fast32_t absA;
-
-    sign = (a < 0);
-    if ( ! (a & 0x7FFFFFFF) ) {
-        uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0;
-        return uZ.f;
-    }
-    absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-    return softfloat_normRoundPackToF32( sign, 0x9C, absA );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t i32_to_f32( int32_t a )
+{
+    bool sign;
+    union ui32_f32 uZ;
+    uint_fast32_t absA;
+
+    sign = (a < 0);
+    if ( ! (a & 0x7FFFFFFF) ) {
+        uZ.ui = sign ? packToF32UI( 1, 0x9E, 0 ) : 0;
+        return uZ.f;
+    }
+    absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
+    return softfloat_normRoundPackToF32( sign, 0x9C, absA );
+
+}
+
diff --git a/softfloat/source/i32_to_f64.c b/softfloat/source/i32_to_f64.c
index 24feda5..64662bb 100644
--- a/softfloat/source/i32_to_f64.c
+++ b/softfloat/source/i32_to_f64.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t i32_to_f64( int32_t a )
-{
-    uint_fast64_t uiZ;
-    bool sign;
-    uint_fast32_t absA;
-    int_fast8_t shiftDist;
-    union ui64_f64 uZ;
-
-    if ( ! a ) {
-        uiZ = 0;
-    } else {
-        sign = (a < 0);
-        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
-        shiftDist = softfloat_countLeadingZeros32( absA ) + 21;
-        uiZ =
-            packToF64UI(
-                sign, 0x432 - shiftDist, (uint_fast64_t) absA<<shiftDist );
-    }
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t i32_to_f64( int32_t a )
+{
+    uint_fast64_t uiZ;
+    bool sign;
+    uint_fast32_t absA;
+    int_fast8_t shiftDist;
+    union ui64_f64 uZ;
+
+    if ( ! a ) {
+        uiZ = 0;
+    } else {
+        sign = (a < 0);
+        absA = sign ? -(uint_fast32_t) a : (uint_fast32_t) a;
+        shiftDist = softfloat_countLeadingZeros32( absA ) + 21;
+        uiZ =
+            packToF64UI(
+                sign, 0x432 - shiftDist, (uint_fast64_t) absA<<shiftDist );
+    }
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/i64_to_extF80.c b/softfloat/source/i64_to_extF80.c
index a1000be..7253cf7 100644
--- a/softfloat/source/i64_to_extF80.c
+++ b/softfloat/source/i64_to_extF80.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t i64_to_extF80( int64_t a )
-{
-    uint_fast16_t uiZ64;
-    uint_fast64_t absA;
-    bool sign;
-    int_fast8_t shiftDist;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    uiZ64 = 0;
-    absA = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-        shiftDist = softfloat_countLeadingZeros64( absA );
-        uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );
-        absA <<= shiftDist;
-    }
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = absA;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t i64_to_extF80( int64_t a )
+{
+    uint_fast16_t uiZ64;
+    uint_fast64_t absA;
+    bool sign;
+    int_fast8_t shiftDist;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    uiZ64 = 0;
+    absA = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
+        shiftDist = softfloat_countLeadingZeros64( absA );
+        uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );
+        absA <<= shiftDist;
+    }
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = absA;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/i64_to_extF80M.c b/softfloat/source/i64_to_extF80M.c
index 4838dde..0bf67ff 100644
--- a/softfloat/source/i64_to_extF80M.c
+++ b/softfloat/source/i64_to_extF80M.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = i64_to_extF80( a );
-
-}
-
-#else
-
-void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiZ64;
-    uint64_t sigZ;
-    bool sign;
-    uint64_t absA;
-    int_fast8_t shiftDist;
-
-    zSPtr = (struct extFloat80M *) zPtr;
-    uiZ64 = 0;
-    sigZ = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint64_t) a : (uint64_t) a;
-        shiftDist = softfloat_countLeadingZeros64( absA );
-        uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );
-        sigZ = absA<<shiftDist;
-    }
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = sigZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = i64_to_extF80( a );
+
+}
+
+#else
+
+void i64_to_extF80M( int64_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiZ64;
+    uint64_t sigZ;
+    bool sign;
+    uint64_t absA;
+    int_fast8_t shiftDist;
+
+    zSPtr = (struct extFloat80M *) zPtr;
+    uiZ64 = 0;
+    sigZ = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint64_t) a : (uint64_t) a;
+        shiftDist = softfloat_countLeadingZeros64( absA );
+        uiZ64 = packToExtF80UI64( sign, 0x403E - shiftDist );
+        sigZ = absA<<shiftDist;
+    }
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = sigZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/i64_to_f128.c b/softfloat/source/i64_to_f128.c
index fcb0179..a2b6dea 100644
--- a/softfloat/source/i64_to_f128.c
+++ b/softfloat/source/i64_to_f128.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t i64_to_f128( int64_t a )
-{
-    uint_fast64_t uiZ64, uiZ0;
-    bool sign;
-    uint_fast64_t absA;
-    int_fast8_t shiftDist;
-    struct uint128 zSig;
-    union ui128_f128 uZ;
-
-    if ( ! a ) {
-        uiZ64 = 0;
-        uiZ0  = 0;
-    } else {
-        sign = (a < 0);
-        absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-        shiftDist = softfloat_countLeadingZeros64( absA ) + 49;
-        if ( 64 <= shiftDist ) {
-            zSig.v64 = absA<<(shiftDist - 64);
-            zSig.v0  = 0;
-        } else {
-            zSig = softfloat_shortShiftLeft128( 0, absA, shiftDist );
-        }
-        uiZ64 = packToF128UI64( sign, 0x406E - shiftDist, zSig.v64 );
-        uiZ0  = zSig.v0;
-    }
-    uZ.ui.v64 = uiZ64;
-    uZ.ui.v0  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t i64_to_f128( int64_t a )
+{
+    uint_fast64_t uiZ64, uiZ0;
+    bool sign;
+    uint_fast64_t absA;
+    int_fast8_t shiftDist;
+    struct uint128 zSig;
+    union ui128_f128 uZ;
+
+    if ( ! a ) {
+        uiZ64 = 0;
+        uiZ0  = 0;
+    } else {
+        sign = (a < 0);
+        absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
+        shiftDist = softfloat_countLeadingZeros64( absA ) + 49;
+        if ( 64 <= shiftDist ) {
+            zSig.v64 = absA<<(shiftDist - 64);
+            zSig.v0  = 0;
+        } else {
+            zSig = softfloat_shortShiftLeft128( 0, absA, shiftDist );
+        }
+        uiZ64 = packToF128UI64( sign, 0x406E - shiftDist, zSig.v64 );
+        uiZ0  = zSig.v0;
+    }
+    uZ.ui.v64 = uiZ64;
+    uZ.ui.v0  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/i64_to_f128M.c b/softfloat/source/i64_to_f128M.c
index 0a04eb8..7b44ec7 100644
--- a/softfloat/source/i64_to_f128M.c
+++ b/softfloat/source/i64_to_f128M.c
@@ -1,92 +1,92 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void i64_to_f128M( int64_t a, float128_t *zPtr )
-{
-
-    *zPtr = i64_to_f128( a );
-
-}
-
-#else
-
-void i64_to_f128M( int64_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr;
-    uint32_t uiZ96, uiZ64;
-    bool sign;
-    uint64_t absA;
-    uint_fast8_t shiftDist;
-    uint32_t *ptr;
-
-    zWPtr = (uint32_t *) zPtr;
-    uiZ96 = 0;
-    uiZ64 = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-    if ( a ) {
-        sign = (a < 0);
-        absA = sign ? -(uint64_t) a : (uint64_t) a;
-        shiftDist = softfloat_countLeadingZeros64( absA ) + 17;
-        if ( shiftDist < 32 ) {
-            ptr = zWPtr + indexMultiwordHi( 4, 3 );
-            ptr[indexWord( 3, 2 )] = 0;
-            ptr[indexWord( 3, 1 )] = absA>>32;
-            ptr[indexWord( 3, 0 )] = absA;
-            softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
-            ptr[indexWordHi( 3 )] =
-                packToF128UI96(
-                    sign, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );
-            return;
-        }
-        absA <<= shiftDist - 32;
-        uiZ96 = packToF128UI96( sign, 0x404E - shiftDist, absA>>32 );
-        uiZ64 = absA;
-    }
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = uiZ64;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void i64_to_f128M( int64_t a, float128_t *zPtr )
+{
+
+    *zPtr = i64_to_f128( a );
+
+}
+
+#else
+
+void i64_to_f128M( int64_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr;
+    uint32_t uiZ96, uiZ64;
+    bool sign;
+    uint64_t absA;
+    uint_fast8_t shiftDist;
+    uint32_t *ptr;
+
+    zWPtr = (uint32_t *) zPtr;
+    uiZ96 = 0;
+    uiZ64 = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+    if ( a ) {
+        sign = (a < 0);
+        absA = sign ? -(uint64_t) a : (uint64_t) a;
+        shiftDist = softfloat_countLeadingZeros64( absA ) + 17;
+        if ( shiftDist < 32 ) {
+            ptr = zWPtr + indexMultiwordHi( 4, 3 );
+            ptr[indexWord( 3, 2 )] = 0;
+            ptr[indexWord( 3, 1 )] = absA>>32;
+            ptr[indexWord( 3, 0 )] = absA;
+            softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
+            ptr[indexWordHi( 3 )] =
+                packToF128UI96(
+                    sign, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );
+            return;
+        }
+        absA <<= shiftDist - 32;
+        uiZ96 = packToF128UI96( sign, 0x404E - shiftDist, absA>>32 );
+        uiZ64 = absA;
+    }
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = uiZ64;
+
+}
+
+#endif
+
diff --git a/softfloat/source/i64_to_f16.c b/softfloat/source/i64_to_f16.c
index cef7b61..f16eccf 100644
--- a/softfloat/source/i64_to_f16.c
+++ b/softfloat/source/i64_to_f16.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t i64_to_f16( int64_t a )
-{
-    bool sign;
-    uint_fast64_t absA;
-    int_fast8_t shiftDist;
-    union ui16_f16 u;
-    uint_fast16_t sig;
-
-    sign = (a < 0);
-    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-    shiftDist = softfloat_countLeadingZeros64( absA ) - 53;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF16UI(
-                    sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 4;
-        sig =
-            (shiftDist < 0)
-                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
-                : (uint_fast16_t) absA<<shiftDist;
-        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t i64_to_f16( int64_t a )
+{
+    bool sign;
+    uint_fast64_t absA;
+    int_fast8_t shiftDist;
+    union ui16_f16 u;
+    uint_fast16_t sig;
+
+    sign = (a < 0);
+    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
+    shiftDist = softfloat_countLeadingZeros64( absA ) - 53;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF16UI(
+                    sign, 0x18 - shiftDist, (uint_fast16_t) absA<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 4;
+        sig =
+            (shiftDist < 0)
+                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
+                : (uint_fast16_t) absA<<shiftDist;
+        return softfloat_roundPackToF16( sign, 0x1C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/i64_to_f32.c b/softfloat/source/i64_to_f32.c
index ca1dc74..391e1ae 100644
--- a/softfloat/source/i64_to_f32.c
+++ b/softfloat/source/i64_to_f32.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t i64_to_f32( int64_t a )
-{
-    bool sign;
-    uint_fast64_t absA;
-    int_fast8_t shiftDist;
-    union ui32_f32 u;
-    uint_fast32_t sig;
-
-    sign = (a < 0);
-    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-    shiftDist = softfloat_countLeadingZeros64( absA ) - 40;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF32UI(
-                    sign, 0x95 - shiftDist, (uint_fast32_t) absA<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 7;
-        sig =
-            (shiftDist < 0)
-                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
-                : (uint_fast32_t) absA<<shiftDist;
-        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t i64_to_f32( int64_t a )
+{
+    bool sign;
+    uint_fast64_t absA;
+    int_fast8_t shiftDist;
+    union ui32_f32 u;
+    uint_fast32_t sig;
+
+    sign = (a < 0);
+    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
+    shiftDist = softfloat_countLeadingZeros64( absA ) - 40;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF32UI(
+                    sign, 0x95 - shiftDist, (uint_fast32_t) absA<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 7;
+        sig =
+            (shiftDist < 0)
+                ? softfloat_shortShiftRightJam64( absA, -shiftDist )
+                : (uint_fast32_t) absA<<shiftDist;
+        return softfloat_roundPackToF32( sign, 0x9C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/i64_to_f64.c b/softfloat/source/i64_to_f64.c
index ea9e821..6d26ddc 100644
--- a/softfloat/source/i64_to_f64.c
+++ b/softfloat/source/i64_to_f64.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t i64_to_f64( int64_t a )
-{
-    bool sign;
-    union ui64_f64 uZ;
-    uint_fast64_t absA;
-
-    sign = (a < 0);
-    if ( ! (a & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
-        uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0;
-        return uZ.f;
-    }
-    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
-    return softfloat_normRoundPackToF64( sign, 0x43C, absA );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t i64_to_f64( int64_t a )
+{
+    bool sign;
+    union ui64_f64 uZ;
+    uint_fast64_t absA;
+
+    sign = (a < 0);
+    if ( ! (a & UINT64_C( 0x7FFFFFFFFFFFFFFF )) ) {
+        uZ.ui = sign ? packToF64UI( 1, 0x43E, 0 ) : 0;
+        return uZ.f;
+    }
+    absA = sign ? -(uint_fast64_t) a : (uint_fast64_t) a;
+    return softfloat_normRoundPackToF64( sign, 0x43C, absA );
+
+}
+
diff --git a/softfloat/source/include/internals.h b/softfloat/source/include/internals.h
index bd976d1..5e6d4bd 100644
--- a/softfloat/source/include/internals.h
+++ b/softfloat/source/include/internals.h
@@ -1,241 +1,291 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef internals_h
-#define internals_h 1
-
-#include "primitives.h"
-#include "softfloat_types.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-union ui16_f16 {
-    uint16_t ui;
-    float16_t f;
-};
-union ui32_f32 {
-    uint32_t ui;
-    float32_t f;
-};
-union ui64_f64 {
-    uint64_t ui;
-    float64_t f;
-};
-
-#ifdef SOFTFLOAT_FAST_INT64
-union extF80M_extF80 {
-    struct extFloat80M fM;
-    extFloat80_t f;
-};
-union ui128_f128 {
-    struct uint128 ui;
-    float128_t f;
-};
-#endif
-
-enum { softfloat_mulAdd_subC = 1, softfloat_mulAdd_subProd = 2 };
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_roundToUI32(bool, uint_fast64_t, uint_fast8_t, bool);
-
-#ifdef SOFTFLOAT_FAST_INT64
-uint_fast64_t softfloat_roundToUI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
-#else
-uint_fast64_t softfloat_roundMToUI64(bool, uint32_t*, uint_fast8_t, bool);
-#endif
-
-int_fast32_t softfloat_roundToI32(bool, uint_fast64_t, uint_fast8_t, bool);
-
-#ifdef SOFTFLOAT_FAST_INT64
-int_fast64_t softfloat_roundToI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
-#else
-int_fast64_t softfloat_roundMToI64(bool, uint32_t*, uint_fast8_t, bool);
-#endif
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signF16UI(a) ((bool)((uint16_t)(a) >> 15))
-#define expF16UI(a) ((int_fast8_t)((a) >> 10) & 0x1F)
-#define fracF16UI(a) ((a)&0x03FF)
-#define packToF16UI(sign, exp, sig) (((uint16_t)(sign) << 15) + ((uint16_t)(exp) << 10) + (sig))
-
-#define isNaNF16UI(a) (((~(a)&0x7C00) == 0) && ((a)&0x03FF))
-
-struct exp8_sig16 {
-    int_fast8_t exp;
-    uint_fast16_t sig;
-};
-struct exp8_sig16 softfloat_normSubnormalF16Sig(uint_fast16_t);
-
-float16_t softfloat_roundPackToF16(bool, int_fast16_t, uint_fast16_t);
-float16_t softfloat_normRoundPackToF16(bool, int_fast16_t, uint_fast16_t);
-
-float16_t softfloat_addMagsF16(uint_fast16_t, uint_fast16_t);
-float16_t softfloat_subMagsF16(uint_fast16_t, uint_fast16_t);
-float16_t softfloat_mulAddF16(uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t);
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signF32UI(a) ((bool)((uint32_t)(a) >> 31))
-#define expF32UI(a) ((int_fast16_t)((a) >> 23) & 0xFF)
-#define fracF32UI(a) ((a)&0x007FFFFF)
-#define packToF32UI(sign, exp, sig) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 23) + (sig))
-
-#define isNaNF32UI(a) (((~(a)&0x7F800000) == 0) && ((a)&0x007FFFFF))
-
-struct exp16_sig32 {
-    int_fast16_t exp;
-    uint_fast32_t sig;
-};
-struct exp16_sig32 softfloat_normSubnormalF32Sig(uint_fast32_t);
-
-float32_t softfloat_roundPackToF32(bool, int_fast16_t, uint_fast32_t);
-float32_t softfloat_normRoundPackToF32(bool, int_fast16_t, uint_fast32_t);
-
-float32_t softfloat_addMagsF32(uint_fast32_t, uint_fast32_t);
-float32_t softfloat_subMagsF32(uint_fast32_t, uint_fast32_t);
-float32_t softfloat_mulAddF32(uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t);
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signF64UI(a) ((bool)((uint64_t)(a) >> 63))
-#define expF64UI(a) ((int_fast16_t)((a) >> 52) & 0x7FF)
-#define fracF64UI(a) ((a)&UINT64_C(0x000FFFFFFFFFFFFF))
-#define packToF64UI(sign, exp, sig) ((uint64_t)(((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 52) + (sig)))
-
-#define isNaNF64UI(a) (((~(a)&UINT64_C(0x7FF0000000000000)) == 0) && ((a)&UINT64_C(0x000FFFFFFFFFFFFF)))
-
-struct exp16_sig64 {
-    int_fast16_t exp;
-    uint_fast64_t sig;
-};
-struct exp16_sig64 softfloat_normSubnormalF64Sig(uint_fast64_t);
-
-float64_t softfloat_roundPackToF64(bool, int_fast16_t, uint_fast64_t);
-float64_t softfloat_normRoundPackToF64(bool, int_fast16_t, uint_fast64_t);
-
-float64_t softfloat_addMagsF64(uint_fast64_t, uint_fast64_t, bool);
-float64_t softfloat_subMagsF64(uint_fast64_t, uint_fast64_t, bool);
-float64_t softfloat_mulAddF64(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signExtF80UI64(a64) ((bool)((uint16_t)(a64) >> 15))
-#define expExtF80UI64(a64) ((a64)&0x7FFF)
-#define packToExtF80UI64(sign, exp) ((uint_fast16_t)(sign) << 15 | (exp))
-
-#define isNaNExtF80UI(a64, a0) ((((a64)&0x7FFF) == 0x7FFF) && ((a0)&UINT64_C(0x7FFFFFFFFFFFFFFF)))
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-
-struct exp32_sig64 {
-    int_fast32_t exp;
-    uint64_t sig;
-};
-struct exp32_sig64 softfloat_normSubnormalExtF80Sig(uint_fast64_t);
-
-extFloat80_t softfloat_roundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
-extFloat80_t softfloat_normRoundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
-
-extFloat80_t softfloat_addMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
-extFloat80_t softfloat_subMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signF128UI64(a64) ((bool)((uint64_t)(a64) >> 63))
-#define expF128UI64(a64) ((int_fast32_t)((a64) >> 48) & 0x7FFF)
-#define fracF128UI64(a64) ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))
-#define packToF128UI64(sign, exp, sig64) (((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 48) + (sig64))
-
-#define isNaNF128UI(a64, a0) (((~(a64)&UINT64_C(0x7FFF000000000000)) == 0) && (a0 || ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))))
-
-struct exp32_sig128 {
-    int_fast32_t exp;
-    struct uint128 sig;
-};
-struct exp32_sig128 softfloat_normSubnormalF128Sig(uint_fast64_t, uint_fast64_t);
-
-float128_t softfloat_roundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t);
-float128_t softfloat_normRoundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t);
-
-float128_t softfloat_addMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
-float128_t softfloat_subMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
-float128_t softfloat_mulAddF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
-
-#else
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-
-bool softfloat_tryPropagateNaNExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*);
-void softfloat_invalidExtF80M(struct extFloat80M*);
-
-int softfloat_normExtF80SigM(uint64_t*);
-
-void softfloat_roundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
-void softfloat_normRoundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
-
-void softfloat_addExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*, bool);
-
-int softfloat_compareNonnormExtF80M(const struct extFloat80M*, const struct extFloat80M*);
-
-/*----------------------------------------------------------------------------
- *----------------------------------------------------------------------------*/
-#define signF128UI96(a96) ((bool)((uint32_t)(a96) >> 31))
-#define expF128UI96(a96) ((int32_t)((a96) >> 16) & 0x7FFF)
-#define fracF128UI96(a96) ((a96)&0x0000FFFF)
-#define packToF128UI96(sign, exp, sig96) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 16) + (sig96))
-
-bool softfloat_isNaNF128M(const uint32_t*);
-
-bool softfloat_tryPropagateNaNF128M(const uint32_t*, const uint32_t*, uint32_t*);
-void softfloat_invalidF128M(uint32_t*);
-
-int softfloat_shiftNormSigF128M(const uint32_t*, uint_fast8_t, uint32_t*);
-
-void softfloat_roundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
-void softfloat_normRoundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
-
-void softfloat_addF128M(const uint32_t*, const uint32_t*, uint32_t*, bool);
-void softfloat_mulAddF128M(const uint32_t*, const uint32_t*, const uint32_t*, uint32_t*, uint_fast8_t);
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef internals_h
+#define internals_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitives.h"
+#include "softfloat_types.h"
+
+union ui16_f16 { uint16_t ui; float16_t f; };
+union ui16_bf16 { uint16_t ui; bfloat16_t f; };
+union ui32_f32 { uint32_t ui; float32_t f; };
+union ui64_f64 { uint64_t ui; float64_t f; };
+
+#ifdef SOFTFLOAT_FAST_INT64
+union extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; };
+union ui128_f128 { struct uint128 ui; float128_t f; };
+#endif
+
+enum {
+    softfloat_mulAdd_subC    = 1,
+    softfloat_mulAdd_subProd = 2
+};
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
+
+#ifdef SOFTFLOAT_FAST_INT64
+uint_fast64_t
+ softfloat_roundToUI64(
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+#else
+uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
+#endif
+
+int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
+
+#ifdef SOFTFLOAT_FAST_INT64
+int_fast64_t
+ softfloat_roundToI64(
+     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+#else
+int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
+#endif
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signF16UI( a ) ((bool) ((uint16_t) (a)>>15))
+#define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F)
+#define fracF16UI( a ) ((a) & 0x03FF)
+#define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig))
+
+#define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF))
+
+struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; };
+struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
+
+float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
+float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
+
+float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
+float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
+float16_t
+ softfloat_mulAddF16(
+     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signBF16UI( a ) ((bool) ((uint16_t) (a)>>15))
+#define expBF16UI( a ) ((int_fast16_t) ((a)>>7) & 0xFF)
+#define fracBF16UI( a ) ((a) & 0x07F)
+#define packToBF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<7) + (sig))
+
+#define isNaNBF16UI( a ) (((~(a) & 0x7FC0) == 0) && ((a) & 0x07F))
+
+bfloat16_t softfloat_roundPackToBF16( bool, int_fast16_t, uint_fast16_t );
+struct exp8_sig16 softfloat_normSubnormalBF16Sig( uint_fast16_t );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signF32UI( a ) ((bool) ((uint32_t) (a)>>31))
+#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF)
+#define fracF32UI( a ) ((a) & 0x007FFFFF)
+#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))
+
+#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))
+
+struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };
+struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
+
+float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
+float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
+
+float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
+float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
+float32_t
+ softfloat_mulAddF32(
+     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signF64UI( a ) ((bool) ((uint64_t) (a)>>63))
+#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF)
+#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))
+#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig)))
+
+#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )))
+
+struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };
+struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
+
+float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
+float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
+
+float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
+float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
+float64_t
+ softfloat_mulAddF64(
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15))
+#define expExtF80UI64( a64 ) ((a64) & 0x7FFF)
+#define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp))
+
+#define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+
+struct exp32_sig64 { int_fast32_t exp; uint64_t sig; };
+struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t );
+
+extFloat80_t
+ softfloat_roundPackToExtF80(
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+extFloat80_t
+ softfloat_normRoundPackToExtF80(
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+
+extFloat80_t
+ softfloat_addMagsExtF80(
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+extFloat80_t
+ softfloat_subMagsExtF80(
+     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63))
+#define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF)
+#define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))
+#define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64))
+
+#define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))))
+
+struct exp32_sig128 { int_fast32_t exp; struct uint128 sig; };
+struct exp32_sig128
+ softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t );
+
+float128_t
+ softfloat_roundPackToF128(
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
+float128_t
+ softfloat_normRoundPackToF128(
+     bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
+
+float128_t
+ softfloat_addMagsF128(
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+float128_t
+ softfloat_subMagsF128(
+     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
+float128_t
+ softfloat_mulAddF128(
+     uint_fast64_t,
+     uint_fast64_t,
+     uint_fast64_t,
+     uint_fast64_t,
+     uint_fast64_t,
+     uint_fast64_t,
+     uint_fast8_t
+ );
+
+#else
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+
+bool
+ softfloat_tryPropagateNaNExtF80M(
+     const struct extFloat80M *,
+     const struct extFloat80M *,
+     struct extFloat80M *
+ );
+void softfloat_invalidExtF80M( struct extFloat80M * );
+
+int softfloat_normExtF80SigM( uint64_t * );
+
+void
+ softfloat_roundPackMToExtF80M(
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+void
+ softfloat_normRoundPackMToExtF80M(
+     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+
+void
+ softfloat_addExtF80M(
+     const struct extFloat80M *,
+     const struct extFloat80M *,
+     struct extFloat80M *,
+     bool
+ );
+
+int
+ softfloat_compareNonnormExtF80M(
+     const struct extFloat80M *, const struct extFloat80M * );
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+#define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31))
+#define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF)
+#define fracF128UI96( a96 ) ((a96) & 0x0000FFFF)
+#define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96))
+
+bool softfloat_isNaNF128M( const uint32_t * );
+
+bool
+ softfloat_tryPropagateNaNF128M(
+     const uint32_t *, const uint32_t *, uint32_t * );
+void softfloat_invalidF128M( uint32_t * );
+
+int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
+
+void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
+void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
+
+void
+ softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
+void
+ softfloat_mulAddF128M(
+     const uint32_t *,
+     const uint32_t *,
+     const uint32_t *,
+     uint32_t *,
+     uint_fast8_t
+ );
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/include/opts-GCC.h b/softfloat/source/include/opts-GCC.h
index 99a4127..769cc27 100644
--- a/softfloat/source/include/opts-GCC.h
+++ b/softfloat/source/include/opts-GCC.h
@@ -1,113 +1,113 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2017 The Regents of the University of California.  All rights
-reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef opts_GCC_h
-#define opts_GCC_h 1
-
-#ifdef INLINE
-
-#include "primitiveTypes.h"
-#include <stdint.h>
-
-#ifdef SOFTFLOAT_BUILTIN_CLZ
-
-INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) { return a ? __builtin_clz(a) - 16 : 16; }
-#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16
-
-INLINE uint_fast8_t softfloat_countLeadingZeros32(uint32_t a) { return a ? __builtin_clz(a) : 32; }
-#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32
-
-INLINE uint_fast8_t softfloat_countLeadingZeros64(uint64_t a) { return a ? __builtin_clzll(a) : 64; }
-#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64
-
-#endif
-
-#ifdef SOFTFLOAT_INTRINSIC_INT128
-
-INLINE struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b) {
-    union {
-        unsigned __int128 ui;
-        struct uint128 s;
-    } uZ;
-    uZ.ui = (unsigned __int128)a * ((uint_fast64_t)b << 32);
-    return uZ.s;
-}
-#define softfloat_mul64ByShifted32To128 softfloat_mul64ByShifted32To128
-
-INLINE struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b) {
-    union {
-        unsigned __int128 ui;
-        struct uint128 s;
-    } uZ;
-    uZ.ui = (unsigned __int128)a * b;
-    return uZ.s;
-}
-#define softfloat_mul64To128 softfloat_mul64To128
-
-INLINE
-struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b) {
-    union {
-        unsigned __int128 ui;
-        struct uint128 s;
-    } uZ;
-    uZ.ui = ((unsigned __int128)a64 << 64 | a0) * b;
-    return uZ.s;
-}
-#define softfloat_mul128By32 softfloat_mul128By32
-
-INLINE
-void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t* zPtr) {
-    unsigned __int128 z0, mid1, mid, z128;
-    z0 = (unsigned __int128)a0 * b0;
-    mid1 = (unsigned __int128)a64 * b0;
-    mid = mid1 + (unsigned __int128)a0 * b64;
-    z128 = (unsigned __int128)a64 * b64;
-    z128 += (unsigned __int128)(mid < mid1) << 64 | mid >> 64;
-    mid <<= 64;
-    z0 += mid;
-    z128 += (z0 < mid);
-    zPtr[indexWord(4, 0)] = z0;
-    zPtr[indexWord(4, 1)] = z0 >> 64;
-    zPtr[indexWord(4, 2)] = z128;
-    zPtr[indexWord(4, 3)] = z128 >> 64;
-}
-#define softfloat_mul128To256M softfloat_mul128To256M
-
-#endif
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2017 The Regents of the University of California.  All rights
+reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef opts_GCC_h
+#define opts_GCC_h 1
+
+#ifdef INLINE
+
+#include "primitiveTypes.h"
+#include <stdint.h>
+
+#ifdef SOFTFLOAT_BUILTIN_CLZ
+
+INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) { return a ? __builtin_clz(a) - 16 : 16; }
+#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16
+
+INLINE uint_fast8_t softfloat_countLeadingZeros32(uint32_t a) { return a ? __builtin_clz(a) : 32; }
+#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32
+
+INLINE uint_fast8_t softfloat_countLeadingZeros64(uint64_t a) { return a ? __builtin_clzll(a) : 64; }
+#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64
+
+#endif
+
+#ifdef SOFTFLOAT_INTRINSIC_INT128
+
+INLINE struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b) {
+    union {
+        unsigned __int128 ui;
+        struct uint128 s;
+    } uZ;
+    uZ.ui = (unsigned __int128)a * ((uint_fast64_t)b << 32);
+    return uZ.s;
+}
+#define softfloat_mul64ByShifted32To128 softfloat_mul64ByShifted32To128
+
+INLINE struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b) {
+    union {
+        unsigned __int128 ui;
+        struct uint128 s;
+    } uZ;
+    uZ.ui = (unsigned __int128)a * b;
+    return uZ.s;
+}
+#define softfloat_mul64To128 softfloat_mul64To128
+
+INLINE
+struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b) {
+    union {
+        unsigned __int128 ui;
+        struct uint128 s;
+    } uZ;
+    uZ.ui = ((unsigned __int128)a64 << 64 | a0) * b;
+    return uZ.s;
+}
+#define softfloat_mul128By32 softfloat_mul128By32
+
+INLINE
+void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t* zPtr) {
+    unsigned __int128 z0, mid1, mid, z128;
+    z0 = (unsigned __int128)a0 * b0;
+    mid1 = (unsigned __int128)a64 * b0;
+    mid = mid1 + (unsigned __int128)a0 * b64;
+    z128 = (unsigned __int128)a64 * b64;
+    z128 += (unsigned __int128)(mid < mid1) << 64 | mid >> 64;
+    mid <<= 64;
+    z0 += mid;
+    z128 += (z0 < mid);
+    zPtr[indexWord(4, 0)] = z0;
+    zPtr[indexWord(4, 1)] = z0 >> 64;
+    zPtr[indexWord(4, 2)] = z128;
+    zPtr[indexWord(4, 3)] = z128 >> 64;
+}
+#define softfloat_mul128To256M softfloat_mul128To256M
+
+#endif
+
+#endif
+
+#endif
diff --git a/softfloat/source/include/primitiveTypes.h b/softfloat/source/include/primitiveTypes.h
index fca21f9..e305400 100644
--- a/softfloat/source/include/primitiveTypes.h
+++ b/softfloat/source/include/primitiveTypes.h
@@ -1,100 +1,85 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef primitiveTypes_h
-#define primitiveTypes_h 1
-
-#include <stdint.h>
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-#ifdef LITTLEENDIAN
-struct uint128 {
-    uint64_t v0, v64;
-};
-struct uint64_extra {
-    uint64_t extra, v;
-};
-struct uint128_extra {
-    uint64_t extra;
-    struct uint128 v;
-};
-#else
-struct uint128 {
-    uint64_t v64, v0;
-};
-struct uint64_extra {
-    uint64_t v, extra;
-};
-struct uint128_extra {
-    struct uint128 v;
-    uint64_t extra;
-};
-#endif
-
-#endif
-
-/*----------------------------------------------------------------------------
-| These macros are used to isolate the differences in word order between big-
-| endian and little-endian platforms.
-*----------------------------------------------------------------------------*/
-#ifdef LITTLEENDIAN
-#define wordIncr 1
-#define indexWord(total, n) (n)
-#define indexWordHi(total) ((total)-1)
-#define indexWordLo(total) 0
-#define indexMultiword(total, m, n) (n)
-#define indexMultiwordHi(total, n) ((total) - (n))
-#define indexMultiwordLo(total, n) 0
-#define indexMultiwordHiBut(total, n) (n)
-#define indexMultiwordLoBut(total, n) 0
-#define INIT_UINTM4(v3, v2, v1, v0)                                                                                                        \
-    { v0, v1, v2, v3 }
-#else
-#define wordIncr -1
-#define indexWord(total, n) ((total)-1 - (n))
-#define indexWordHi(total) 0
-#define indexWordLo(total) ((total)-1)
-#define indexMultiword(total, m, n) ((total)-1 - (m))
-#define indexMultiwordHi(total, n) 0
-#define indexMultiwordLo(total, n) ((total) - (n))
-#define indexMultiwordHiBut(total, n) 0
-#define indexMultiwordLoBut(total, n) (n)
-#define INIT_UINTM4(v3, v2, v1, v0)                                                                                                        \
-    { v3, v2, v1, v0 }
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef primitiveTypes_h
+#define primitiveTypes_h 1
+
+#include <stdint.h>
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+#ifdef LITTLEENDIAN
+struct uint128 { uint64_t v0, v64; };
+struct uint64_extra { uint64_t extra, v; };
+struct uint128_extra { uint64_t extra; struct uint128 v; };
+#else
+struct uint128 { uint64_t v64, v0; };
+struct uint64_extra { uint64_t v, extra; };
+struct uint128_extra { struct uint128 v; uint64_t extra; };
+#endif
+
+#endif
+
+/*----------------------------------------------------------------------------
+| These macros are used to isolate the differences in word order between big-
+| endian and little-endian platforms.
+*----------------------------------------------------------------------------*/
+#ifdef LITTLEENDIAN
+#define wordIncr 1
+#define indexWord( total, n ) (n)
+#define indexWordHi( total ) ((total) - 1)
+#define indexWordLo( total ) 0
+#define indexMultiword( total, m, n ) (n)
+#define indexMultiwordHi( total, n ) ((total) - (n))
+#define indexMultiwordLo( total, n ) 0
+#define indexMultiwordHiBut( total, n ) (n)
+#define indexMultiwordLoBut( total, n ) 0
+#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 }
+#else
+#define wordIncr -1
+#define indexWord( total, n ) ((total) - 1 - (n))
+#define indexWordHi( total ) 0
+#define indexWordLo( total ) ((total) - 1)
+#define indexMultiword( total, m, n ) ((total) - 1 - (m))
+#define indexMultiwordHi( total, n ) 0
+#define indexMultiwordLo( total, n ) ((total) - (n))
+#define indexMultiwordHiBut( total, n ) 0
+#define indexMultiwordLoBut( total, n ) (n)
+#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 }
+#endif
+
+#endif
+
diff --git a/softfloat/source/include/primitives.h b/softfloat/source/include/primitives.h
index 11967d2..1084781 100644
--- a/softfloat/source/include/primitives.h
+++ b/softfloat/source/include/primitives.h
@@ -1,1030 +1,1160 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef primitives_h
-#define primitives_h 1
-
-#include "primitiveTypes.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifndef softfloat_shortShiftRightJam64
-/*----------------------------------------------------------------------------
-| Shifts 'a' right by the number of bits given in 'dist', which must be in
-| the range 1 to 63.  If any nonzero bits are shifted off, they are "jammed"
-| into the least-significant bit of the shifted value by setting the least-
-| significant bit to 1.  This shifted-and-jammed value is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist) { return a >> dist | ((a & (((uint_fast64_t)1 << dist) - 1)) != 0); }
-#else
-uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shiftRightJam32
-/*----------------------------------------------------------------------------
-| Shifts 'a' right by the number of bits given in 'dist', which must not
-| be zero.  If any nonzero bits are shifted off, they are "jammed" into the
-| least-significant bit of the shifted value by setting the least-significant
-| bit to 1.  This shifted-and-jammed value is returned.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
-| greater than 32, the result will be either 0 or 1, depending on whether 'a'
-| is zero or nonzero.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist) {
-    return (dist < 31) ? a >> dist | ((uint32_t)(a << (-dist & 31)) != 0) : (a != 0);
-}
-#else
-uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shiftRightJam64
-/*----------------------------------------------------------------------------
-| Shifts 'a' right by the number of bits given in 'dist', which must not
-| be zero.  If any nonzero bits are shifted off, they are "jammed" into the
-| least-significant bit of the shifted value by setting the least-significant
-| bit to 1.  This shifted-and-jammed value is returned.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
-| greater than 64, the result will be either 0 or 1, depending on whether 'a'
-| is zero or nonzero.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist) {
-    return (dist < 63) ? a >> dist | ((uint64_t)(a << (-dist & 63)) != 0) : (a != 0);
-}
-#else
-uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist);
-#endif
-#endif
-
-/*----------------------------------------------------------------------------
-| A constant table that translates an 8-bit unsigned integer (the array index)
-| into the number of leading 0 bits before the most-significant 1 of that
-| integer.  For integer zero (index 0), the corresponding table element is 8.
-*----------------------------------------------------------------------------*/
-extern const uint_least8_t softfloat_countLeadingZeros8[256];
-
-#ifndef softfloat_countLeadingZeros16
-/*----------------------------------------------------------------------------
-| Returns the number of leading 0 bits before the most-significant 1 bit of
-| 'a'.  If 'a' is zero, 16 is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) {
-    uint_fast8_t count = 8;
-    if(0x100 <= a) {
-        count = 0;
-        a >>= 8;
-    }
-    count += softfloat_countLeadingZeros8[a];
-    return count;
-}
-#else
-uint_fast8_t softfloat_countLeadingZeros16(uint16_t a);
-#endif
-#endif
-
-#ifndef softfloat_countLeadingZeros32
-/*----------------------------------------------------------------------------
-| Returns the number of leading 0 bits before the most-significant 1 bit of
-| 'a'.  If 'a' is zero, 32 is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE uint_fast8_t softfloat_countLeadingZeros32(uint32_t a) {
-    uint_fast8_t count = 0;
-    if(a < 0x10000) {
-        count = 16;
-        a <<= 16;
-    }
-    if(a < 0x1000000) {
-        count += 8;
-        a <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[a >> 24];
-    return count;
-}
-#else
-uint_fast8_t softfloat_countLeadingZeros32(uint32_t a);
-#endif
-#endif
-
-#ifndef softfloat_countLeadingZeros64
-/*----------------------------------------------------------------------------
-| Returns the number of leading 0 bits before the most-significant 1 bit of
-| 'a'.  If 'a' is zero, 64 is returned.
-*----------------------------------------------------------------------------*/
-uint_fast8_t softfloat_countLeadingZeros64(uint64_t a);
-#endif
-
-extern const uint16_t softfloat_approxRecip_1k0s[16];
-extern const uint16_t softfloat_approxRecip_1k1s[16];
-
-#ifndef softfloat_approxRecip32_1
-/*----------------------------------------------------------------------------
-| Returns an approximation to the reciprocal of the number represented by 'a',
-| where 'a' is interpreted as an unsigned fixed-point number with one integer
-| bit and 31 fraction bits.  The 'a' input must be "normalized", meaning that
-| its most-significant bit (bit 31) must be 1.  Thus, if A is the value of
-| the fixed-point interpretation of 'a', then 1 <= A < 2.  The returned value
-| is interpreted as a pure unsigned fraction, having no integer bits and 32
-| fraction bits.  The approximation returned is never greater than the true
-| reciprocal 1/A, and it differs from the true reciprocal by at most 2.006 ulp
-| (units in the last place).
-*----------------------------------------------------------------------------*/
-#ifdef SOFTFLOAT_FAST_DIV64TO32
-#define softfloat_approxRecip32_1(a) ((uint32_t)(UINT64_C(0x7FFFFFFFFFFFFFFF) / (uint32_t)(a)))
-#else
-uint32_t softfloat_approxRecip32_1(uint32_t a);
-#endif
-#endif
-
-extern const uint16_t softfloat_approxRecipSqrt_1k0s[16];
-extern const uint16_t softfloat_approxRecipSqrt_1k1s[16];
-
-#ifndef softfloat_approxRecipSqrt32_1
-/*----------------------------------------------------------------------------
-| Returns an approximation to the reciprocal of the square root of the number
-| represented by 'a', where 'a' is interpreted as an unsigned fixed-point
-| number either with one integer bit and 31 fraction bits or with two integer
-| bits and 30 fraction bits.  The format of 'a' is determined by 'oddExpA',
-| which must be either 0 or 1.  If 'oddExpA' is 1, 'a' is interpreted as
-| having one integer bit, and if 'oddExpA' is 0, 'a' is interpreted as having
-| two integer bits.  The 'a' input must be "normalized", meaning that its
-| most-significant bit (bit 31) must be 1.  Thus, if A is the value of the
-| fixed-point interpretation of 'a', it follows that 1 <= A < 2 when 'oddExpA'
-| is 1, and 2 <= A < 4 when 'oddExpA' is 0.
-|   The returned value is interpreted as a pure unsigned fraction, having
-| no integer bits and 32 fraction bits.  The approximation returned is never
-| greater than the true reciprocal 1/sqrt(A), and it differs from the true
-| reciprocal by at most 2.06 ulp (units in the last place).  The approximation
-| returned is also always within the range 0.5 to 1; thus, the most-
-| significant bit of the result is always set.
-*----------------------------------------------------------------------------*/
-uint32_t softfloat_approxRecipSqrt32_1(unsigned int oddExpA, uint32_t a);
-#endif
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
-| defined.
-*----------------------------------------------------------------------------*/
-
-#ifndef softfloat_eq128
-/*----------------------------------------------------------------------------
-| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
-| and 'a0' is equal to the 128-bit unsigned integer formed by concatenating
-| 'b64' and 'b0'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
-INLINE
-bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 == b64) && (a0 == b0); }
-#else
-bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
-#endif
-#endif
-
-#ifndef softfloat_le128
-/*----------------------------------------------------------------------------
-| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
-| and 'a0' is less than or equal to the 128-bit unsigned integer formed by
-| concatenating 'b64' and 'b0'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
-#else
-bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
-#endif
-#endif
-
-#ifndef softfloat_lt128
-/*----------------------------------------------------------------------------
-| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
-| and 'a0' is less than the 128-bit unsigned integer formed by concatenating
-| 'b64' and 'b0'.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
-#else
-bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftLeft128
-/*----------------------------------------------------------------------------
-| Shifts the 128 bits formed by concatenating 'a64' and 'a0' left by the
-| number of bits given in 'dist', which must be in the range 1 to 63.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
-    struct uint128 z;
-    z.v64 = a64 << dist | a0 >> (-dist & 63);
-    z.v0 = a0 << dist;
-    return z;
-}
-#else
-struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftRight128
-/*----------------------------------------------------------------------------
-| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
-| number of bits given in 'dist', which must be in the range 1 to 63.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
-    struct uint128 z;
-    z.v64 = a64 >> dist;
-    z.v0 = a64 << (-dist & 63) | a0 >> dist;
-    return z;
-}
-#else
-struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftRightJam64Extra
-/*----------------------------------------------------------------------------
-| This function is the same as 'softfloat_shiftRightJam64Extra' (below),
-| except that 'dist' must be in the range 1 to 63.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist) {
-    struct uint64_extra z;
-    z.v = a >> dist;
-    z.extra = a << (-dist & 63) | (extra != 0);
-    return z;
-}
-#else
-struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftRightJam128
-/*----------------------------------------------------------------------------
-| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
-| number of bits given in 'dist', which must be in the range 1 to 63.  If any
-| nonzero bits are shifted off, they are "jammed" into the least-significant
-| bit of the shifted value by setting the least-significant bit to 1.  This
-| shifted-and-jammed value is returned.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
-    uint_fast8_t negDist = -dist;
-    struct uint128 z;
-    z.v64 = a64 >> dist;
-    z.v0 = a64 << (negDist & 63) | a0 >> dist | ((uint64_t)(a0 << (negDist & 63)) != 0);
-    return z;
-}
-#else
-struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftRightJam128Extra
-/*----------------------------------------------------------------------------
-| This function is the same as 'softfloat_shiftRightJam128Extra' (below),
-| except that 'dist' must be in the range 1 to 63.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE
-struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist) {
-    uint_fast8_t negDist = -dist;
-    struct uint128_extra z;
-    z.v.v64 = a64 >> dist;
-    z.v.v0 = a64 << (negDist & 63) | a0 >> dist;
-    z.extra = a0 << (negDist & 63) | (extra != 0);
-    return z;
-}
-#else
-struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shiftRightJam64Extra
-/*----------------------------------------------------------------------------
-| Shifts the 128 bits formed by concatenating 'a' and 'extra' right by 64
-| _plus_ the number of bits given in 'dist', which must not be zero.  This
-| shifted value is at most 64 nonzero bits and is returned in the 'v' field
-| of the 'struct uint64_extra' result.  The 64-bit 'extra' field of the result
-| contains a value formed as follows from the bits that were shifted off:  The
-| _last_ bit shifted off is the most-significant bit of the 'extra' field, and
-| the other 63 bits of the 'extra' field are all zero if and only if _all_but_
-| _the_last_ bits shifted off were all zero.
-|   (This function makes more sense if 'a' and 'extra' are considered to form
-| an unsigned fixed-point number with binary point between 'a' and 'extra'.
-| This fixed-point value is shifted right by the number of bits given in
-| 'dist', and the integer part of this shifted value is returned in the 'v'
-| field of the result.  The fractional part of the shifted value is modified
-| as described above and returned in the 'extra' field of the result.)
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
-INLINE
-struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist) {
-    struct uint64_extra z;
-    if(dist < 64) {
-        z.v = a >> dist;
-        z.extra = a << (-dist & 63);
-    } else {
-        z.v = 0;
-        z.extra = (dist == 64) ? a : (a != 0);
-    }
-    z.extra |= (extra != 0);
-    return z;
-}
-#else
-struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist);
-#endif
-#endif
-
-#ifndef softfloat_shiftRightJam128
-/*----------------------------------------------------------------------------
-| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
-| number of bits given in 'dist', which must not be zero.  If any nonzero bits
-| are shifted off, they are "jammed" into the least-significant bit of the
-| shifted value by setting the least-significant bit to 1.  This shifted-and-
-| jammed value is returned.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
-| greater than 128, the result will be either 0 or 1, depending on whether the
-| original 128 bits are all zeros.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_shiftRightJam128(uint64_t a64, uint64_t a0, uint_fast32_t dist);
-#endif
-
-#ifndef softfloat_shiftRightJam128Extra
-/*----------------------------------------------------------------------------
-| Shifts the 192 bits formed by concatenating 'a64', 'a0', and 'extra' right
-| by 64 _plus_ the number of bits given in 'dist', which must not be zero.
-| This shifted value is at most 128 nonzero bits and is returned in the 'v'
-| field of the 'struct uint128_extra' result.  The 64-bit 'extra' field of the
-| result contains a value formed as follows from the bits that were shifted
-| off:  The _last_ bit shifted off is the most-significant bit of the 'extra'
-| field, and the other 63 bits of the 'extra' field are all zero if and only
-| if _all_but_the_last_ bits shifted off were all zero.
-|   (This function makes more sense if 'a64', 'a0', and 'extra' are considered
-| to form an unsigned fixed-point number with binary point between 'a0' and
-| 'extra'.  This fixed-point value is shifted right by the number of bits
-| given in 'dist', and the integer part of this shifted value is returned
-| in the 'v' field of the result.  The fractional part of the shifted value
-| is modified as described above and returned in the 'extra' field of the
-| result.)
-*----------------------------------------------------------------------------*/
-struct uint128_extra softfloat_shiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist);
-#endif
-
-#ifndef softfloat_shiftRightJam256M
-/*----------------------------------------------------------------------------
-| Shifts the 256-bit unsigned integer pointed to by 'aPtr' right by the number
-| of bits given in 'dist', which must not be zero.  If any nonzero bits are
-| shifted off, they are "jammed" into the least-significant bit of the shifted
-| value by setting the least-significant bit to 1.  This shifted-and-jammed
-| value is stored at the location pointed to by 'zPtr'.  Each of 'aPtr' and
-| 'zPtr' points to an array of four 64-bit elements that concatenate in the
-| platform's normal endian order to form a 256-bit integer.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist'
-| is greater than 256, the stored result will be either 0 or 1, depending on
-| whether the original 256 bits are all zeros.
-*----------------------------------------------------------------------------*/
-void softfloat_shiftRightJam256M(const uint64_t* aPtr, uint_fast32_t dist, uint64_t* zPtr);
-#endif
-
-#ifndef softfloat_add128
-/*----------------------------------------------------------------------------
-| Returns the sum of the 128-bit integer formed by concatenating 'a64' and
-| 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'.  The
-| addition is modulo 2^128, so any carry out is lost.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
-    struct uint128 z;
-    z.v0 = a0 + b0;
-    z.v64 = a64 + b64 + (z.v0 < a0);
-    return z;
-}
-#else
-struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
-#endif
-#endif
-
-#ifndef softfloat_add256M
-/*----------------------------------------------------------------------------
-| Adds the two 256-bit integers pointed to by 'aPtr' and 'bPtr'.  The addition
-| is modulo 2^256, so any carry out is lost.  The sum is stored at the
-| location pointed to by 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to
-| an array of four 64-bit elements that concatenate in the platform's normal
-| endian order to form a 256-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_add256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
-#endif
-
-#ifndef softfloat_sub128
-/*----------------------------------------------------------------------------
-| Returns the difference of the 128-bit integer formed by concatenating 'a64'
-| and 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'.
-| The subtraction is modulo 2^128, so any borrow out (carry out) is lost.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
-    struct uint128 z;
-    z.v0 = a0 - b0;
-    z.v64 = a64 - b64;
-    z.v64 -= (a0 < b0);
-    return z;
-}
-#else
-struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
-#endif
-#endif
-
-#ifndef softfloat_sub256M
-/*----------------------------------------------------------------------------
-| Subtracts the 256-bit integer pointed to by 'bPtr' from the 256-bit integer
-| pointed to by 'aPtr'.  The addition is modulo 2^256, so any borrow out
-| (carry out) is lost.  The difference is stored at the location pointed to
-| by 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to an array of four
-| 64-bit elements that concatenate in the platform's normal endian order to
-| form a 256-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_sub256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
-#endif
-
-#ifndef softfloat_mul64ByShifted32To128
-/*----------------------------------------------------------------------------
-| Returns the 128-bit product of 'a', 'b', and 2^32.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b) {
-    uint_fast64_t mid;
-    struct uint128 z;
-    mid = (uint_fast64_t)(uint32_t)a * b;
-    z.v0 = mid << 32;
-    z.v64 = (uint_fast64_t)(uint32_t)(a >> 32) * b + (mid >> 32);
-    return z;
-}
-#else
-struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b);
-#endif
-#endif
-
-#ifndef softfloat_mul64To128
-/*----------------------------------------------------------------------------
-| Returns the 128-bit product of 'a' and 'b'.
-*----------------------------------------------------------------------------*/
-struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b);
-#endif
-
-#ifndef softfloat_mul128By32
-/*----------------------------------------------------------------------------
-| Returns the product of the 128-bit integer formed by concatenating 'a64' and
-| 'a0', multiplied by 'b'.  The multiplication is modulo 2^128; any overflow
-| bits are discarded.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
-INLINE
-struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b) {
-    struct uint128 z;
-    uint_fast64_t mid;
-    uint_fast32_t carry;
-    z.v0 = a0 * b;
-    mid = (uint_fast64_t)(uint32_t)(a0 >> 32) * b;
-    carry = (uint32_t)((uint_fast32_t)(z.v0 >> 32) - (uint_fast32_t)mid);
-    z.v64 = a64 * b + (uint_fast32_t)((mid + carry) >> 32);
-    return z;
-}
-#else
-struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b);
-#endif
-#endif
-
-#ifndef softfloat_mul128To256M
-/*----------------------------------------------------------------------------
-| Multiplies the 128-bit unsigned integer formed by concatenating 'a64' and
-| 'a0' by the 128-bit unsigned integer formed by concatenating 'b64' and
-| 'b0'.  The 256-bit product is stored at the location pointed to by 'zPtr'.
-| Argument 'zPtr' points to an array of four 64-bit elements that concatenate
-| in the platform's normal endian order to form a 256-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t* zPtr);
-#endif
-
-#else
-
-/*----------------------------------------------------------------------------
-| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
-| defined.
-*----------------------------------------------------------------------------*/
-
-#ifndef softfloat_compare96M
-/*----------------------------------------------------------------------------
-| Compares the two 96-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.
-| Returns -1 if the first integer (A) is less than the second (B); returns 0
-| if the two integers are equal; and returns +1 if the first integer (A)
-| is greater than the second (B).  (The result is thus the signum of A - B.)
-| Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that
-| concatenate in the platform's normal endian order to form a 96-bit integer.
-*----------------------------------------------------------------------------*/
-int_fast8_t softfloat_compare96M(const uint32_t* aPtr, const uint32_t* bPtr);
-#endif
-
-#ifndef softfloat_compare128M
-/*----------------------------------------------------------------------------
-| Compares the two 128-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.
-| Returns -1 if the first integer (A) is less than the second (B); returns 0
-| if the two integers are equal; and returns +1 if the first integer (A)
-| is greater than the second (B).  (The result is thus the signum of A - B.)
-| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
-| concatenate in the platform's normal endian order to form a 128-bit integer.
-*----------------------------------------------------------------------------*/
-int_fast8_t softfloat_compare128M(const uint32_t* aPtr, const uint32_t* bPtr);
-#endif
-
-#ifndef softfloat_shortShiftLeft64To96M
-/*----------------------------------------------------------------------------
-| Extends 'a' to 96 bits and shifts the value left by the number of bits given
-| in 'dist', which must be in the range 1 to 31.  The result is stored at the
-| location pointed to by 'zPtr'.  Argument 'zPtr' points to an array of three
-| 32-bit elements that concatenate in the platform's normal endian order to
-| form a 96-bit integer.
-*----------------------------------------------------------------------------*/
-#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE
-void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr) {
-    zPtr[indexWord(3, 0)] = (uint32_t)a << dist;
-    a >>= 32 - dist;
-    zPtr[indexWord(3, 2)] = a >> 32;
-    zPtr[indexWord(3, 1)] = a;
-}
-#else
-void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr);
-#endif
-#endif
-
-#ifndef softfloat_shortShiftLeftM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must be in the range 1 to 31.  Any nonzero bits shifted off are lost.  The
-| shifted N-bit result is stored at the location pointed to by 'zPtr'.  Each
-| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements
-| that concatenate in the platform's normal endian order to form an N-bit
-| integer.
-*----------------------------------------------------------------------------*/
-void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_shortShiftLeft96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftLeftM' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft96M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(3, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shortShiftLeft128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftLeftM' with
-| 'size_words' = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft128M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(4, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shortShiftLeft160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftLeftM' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft160M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(5, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftLeftM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must not be zero.  Any nonzero bits shifted off are lost.  The shifted
-| N-bit result is stored at the location pointed to by 'zPtr'.  Each of 'aPtr'
-| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that
-| concatenate in the platform's normal endian order to form an N-bit integer.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
-| greater than N, the stored result will be 0.
-*----------------------------------------------------------------------------*/
-void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_shiftLeft96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftLeftM' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft96M(aPtr, dist, zPtr) softfloat_shiftLeftM(3, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftLeft128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftLeftM' with
-| 'size_words' = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft128M(aPtr, dist, zPtr) softfloat_shiftLeftM(4, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftLeft160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftLeftM' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft160M(aPtr, dist, zPtr) softfloat_shiftLeftM(5, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shortShiftRightM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must be in the range 1 to 31.  Any nonzero bits shifted off are lost.  The
-| shifted N-bit result is stored at the location pointed to by 'zPtr'.  Each
-| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements
-| that concatenate in the platform's normal endian order to form an N-bit
-| integer.
-*----------------------------------------------------------------------------*/
-void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_shortShiftRight128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftRightM' with
-| 'size_words' = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRight128M(aPtr, dist, zPtr) softfloat_shortShiftRightM(4, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shortShiftRight160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftRightM' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRight160M(aPtr, dist, zPtr) softfloat_shortShiftRightM(5, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shortShiftRightJamM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must be in the range 1 to 31.  If any nonzero bits are shifted off, they are
-| "jammed" into the least-significant bit of the shifted value by setting the
-| least-significant bit to 1.  This shifted-and-jammed N-bit result is stored
-| at the location pointed to by 'zPtr'.  Each of 'aPtr' and 'zPtr' points
-| to a 'size_words'-long array of 32-bit elements that concatenate in the
-| platform's normal endian order to form an N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_shortShiftRightJamM(uint_fast8_t, const uint32_t*, uint_fast8_t, uint32_t*);
-#endif
-
-#ifndef softfloat_shortShiftRightJam160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shortShiftRightJamM' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRightJam160M(aPtr, dist, zPtr) softfloat_shortShiftRightJamM(5, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftRightM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must not be zero.  Any nonzero bits shifted off are lost.  The shifted
-| N-bit result is stored at the location pointed to by 'zPtr'.  Each of 'aPtr'
-| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that
-| concatenate in the platform's normal endian order to form an N-bit integer.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
-| greater than N, the stored result will be 0.
-*----------------------------------------------------------------------------*/
-void softfloat_shiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_shiftRight96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftRightM' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftRight96M(aPtr, dist, zPtr) softfloat_shiftRightM(3, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftRightJamM
-/*----------------------------------------------------------------------------
-| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
-| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
-| must not be zero.  If any nonzero bits are shifted off, they are "jammed"
-| into the least-significant bit of the shifted value by setting the least-
-| significant bit to 1.  This shifted-and-jammed N-bit result is stored
-| at the location pointed to by 'zPtr'.  Each of 'aPtr' and 'zPtr' points
-| to a 'size_words'-long array of 32-bit elements that concatenate in the
-| platform's normal endian order to form an N-bit integer.
-|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist'
-| is greater than N, the stored result will be either 0 or 1, depending on
-| whether the original N bits are all zeros.
-*----------------------------------------------------------------------------*/
-void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_shiftRightJam96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftRightJamM' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam96M(aPtr, dist, zPtr) softfloat_shiftRightJamM(3, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftRightJam128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftRightJamM' with
-| 'size_words' = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam128M(aPtr, dist, zPtr) softfloat_shiftRightJamM(4, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_shiftRightJam160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_shiftRightJamM' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam160M(aPtr, dist, zPtr) softfloat_shiftRightJamM(5, aPtr, dist, zPtr)
-#endif
-
-#ifndef softfloat_addM
-/*----------------------------------------------------------------------------
-| Adds the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =
-| 'size_words' * 32.  The addition is modulo 2^N, so any carry out is lost.
-| The N-bit sum is stored at the location pointed to by 'zPtr'.  Each of
-| 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long array of 32-bit
-| elements that concatenate in the platform's normal endian order to form an
-| N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_add96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_addM' with 'size_words'
-| = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_add96M(aPtr, bPtr, zPtr) softfloat_addM(3, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_add128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_addM' with 'size_words'
-| = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_add128M(aPtr, bPtr, zPtr) softfloat_addM(4, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_add160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_addM' with 'size_words'
-| = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_add160M(aPtr, bPtr, zPtr) softfloat_addM(5, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_addCarryM
-/*----------------------------------------------------------------------------
-| Adds the two N-bit unsigned integers pointed to by 'aPtr' and 'bPtr', where
-| N = 'size_words' * 32, plus 'carry', which must be either 0 or 1.  The N-bit
-| sum (modulo 2^N) is stored at the location pointed to by 'zPtr', and any
-| carry out is returned as the result.  Each of 'aPtr', 'bPtr', and 'zPtr'
-| points to a 'size_words'-long array of 32-bit elements that concatenate in
-| the platform's normal endian order to form an N-bit integer.
-*----------------------------------------------------------------------------*/
-uint_fast8_t softfloat_addCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_addComplCarryM
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_addCarryM', except that
-| the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed
-| before the addition.
-*----------------------------------------------------------------------------*/
-uint_fast8_t softfloat_addComplCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry,
-                                      uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_addComplCarry96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_addComplCarryM' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_addComplCarry96M(aPtr, bPtr, carry, zPtr) softfloat_addComplCarryM(3, aPtr, bPtr, carry, zPtr)
-#endif
-
-#ifndef softfloat_negXM
-/*----------------------------------------------------------------------------
-| Replaces the N-bit unsigned integer pointed to by 'zPtr' by the
-| 2s-complement of itself, where N = 'size_words' * 32.  Argument 'zPtr'
-| points to a 'size_words'-long array of 32-bit elements that concatenate in
-| the platform's normal endian order to form an N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_negX96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_negXM' with 'size_words'
-| = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_negX96M(zPtr) softfloat_negXM(3, zPtr)
-#endif
-
-#ifndef softfloat_negX128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_negXM' with 'size_words'
-| = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_negX128M(zPtr) softfloat_negXM(4, zPtr)
-#endif
-
-#ifndef softfloat_negX160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_negXM' with 'size_words'
-| = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_negX160M(zPtr) softfloat_negXM(5, zPtr)
-#endif
-
-#ifndef softfloat_negX256M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_negXM' with 'size_words'
-| = 8 (N = 256).
-*----------------------------------------------------------------------------*/
-#define softfloat_negX256M(zPtr) softfloat_negXM(8, zPtr)
-#endif
-
-#ifndef softfloat_sub1XM
-/*----------------------------------------------------------------------------
-| Subtracts 1 from the N-bit integer pointed to by 'zPtr', where N =
-| 'size_words' * 32.  The subtraction is modulo 2^N, so any borrow out (carry
-| out) is lost.  Argument 'zPtr' points to a 'size_words'-long array of 32-bit
-| elements that concatenate in the platform's normal endian order to form an
-| N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_sub1X96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
-| = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_sub1X96M(zPtr) softfloat_sub1XM(3, zPtr)
-#endif
-
-#ifndef softfloat_sub1X160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
-| = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_sub1X160M(zPtr) softfloat_sub1XM(5, zPtr)
-#endif
-
-#ifndef softfloat_subM
-/*----------------------------------------------------------------------------
-| Subtracts the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =
-| 'size_words' * 32.  The subtraction is modulo 2^N, so any borrow out (carry
-| out) is lost.  The N-bit difference is stored at the location pointed to by
-| 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long
-| array of 32-bit elements that concatenate in the platform's normal endian
-| order to form an N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_sub96M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_subM' with 'size_words'
-| = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_sub96M(aPtr, bPtr, zPtr) softfloat_subM(3, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_sub128M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_subM' with 'size_words'
-| = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_sub128M(aPtr, bPtr, zPtr) softfloat_subM(4, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_sub160M
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_subM' with 'size_words'
-| = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_sub160M(aPtr, bPtr, zPtr) softfloat_subM(5, aPtr, bPtr, zPtr)
-#endif
-
-#ifndef softfloat_mul64To128M
-/*----------------------------------------------------------------------------
-| Multiplies 'a' and 'b' and stores the 128-bit product at the location
-| pointed to by 'zPtr'.  Argument 'zPtr' points to an array of four 32-bit
-| elements that concatenate in the platform's normal endian order to form a
-| 128-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_mul64To128M(uint64_t a, uint64_t b, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_mul128MTo256M
-/*----------------------------------------------------------------------------
-| Multiplies the two 128-bit unsigned integers pointed to by 'aPtr' and
-| 'bPtr', and stores the 256-bit product at the location pointed to by 'zPtr'.
-| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
-| concatenate in the platform's normal endian order to form a 128-bit integer.
-| Argument 'zPtr' points to an array of eight 32-bit elements that concatenate
-| to form a 256-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_mul128MTo256M(const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_remStepMBy32
-/*----------------------------------------------------------------------------
-| Performs a "remainder reduction step" as follows:  Arguments 'remPtr' and
-| 'bPtr' both point to N-bit unsigned integers, where N = 'size_words' * 32.
-| Defining R and B as the values of those integers, the expression (R<<'dist')
-| - B * q is computed modulo 2^N, and the N-bit result is stored at the
-| location pointed to by 'zPtr'.  Each of 'remPtr', 'bPtr', and 'zPtr' points
-| to a 'size_words'-long array of 32-bit elements that concatenate in the
-| platform's normal endian order to form an N-bit integer.
-*----------------------------------------------------------------------------*/
-void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uint_fast8_t dist, const uint32_t* bPtr, uint32_t q,
-                            uint32_t* zPtr);
-#endif
-
-#ifndef softfloat_remStep96MBy32
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_remStepMBy32' with
-| 'size_words' = 3 (N = 96).
-*----------------------------------------------------------------------------*/
-#define softfloat_remStep96MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(3, remPtr, dist, bPtr, q, zPtr)
-#endif
-
-#ifndef softfloat_remStep128MBy32
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_remStepMBy32' with
-| 'size_words' = 4 (N = 128).
-*----------------------------------------------------------------------------*/
-#define softfloat_remStep128MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(4, remPtr, dist, bPtr, q, zPtr)
-#endif
-
-#ifndef softfloat_remStep160MBy32
-/*----------------------------------------------------------------------------
-| This function or macro is the same as 'softfloat_remStepMBy32' with
-| 'size_words' = 5 (N = 160).
-*----------------------------------------------------------------------------*/
-#define softfloat_remStep160MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(5, remPtr, dist, bPtr, q, zPtr)
-#endif
-
-#endif
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef primitives_h
+#define primitives_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightJam64
+/*----------------------------------------------------------------------------
+| Shifts 'a' right by the number of bits given in 'dist', which must be in
+| the range 1 to 63.  If any nonzero bits are shifted off, they are "jammed"
+| into the least-significant bit of the shifted value by setting the least-
+| significant bit to 1.  This shifted-and-jammed value is returned.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )
+    { return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0); }
+#else
+uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shiftRightJam32
+/*----------------------------------------------------------------------------
+| Shifts 'a' right by the number of bits given in 'dist', which must not
+| be zero.  If any nonzero bits are shifted off, they are "jammed" into the
+| least-significant bit of the shifted value by setting the least-significant
+| bit to 1.  This shifted-and-jammed value is returned.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
+| greater than 32, the result will be either 0 or 1, depending on whether 'a'
+| is zero or nonzero.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )
+{
+    return
+        (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
+}
+#else
+uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shiftRightJam64
+/*----------------------------------------------------------------------------
+| Shifts 'a' right by the number of bits given in 'dist', which must not
+| be zero.  If any nonzero bits are shifted off, they are "jammed" into the
+| least-significant bit of the shifted value by setting the least-significant
+| bit to 1.  This shifted-and-jammed value is returned.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
+| greater than 64, the result will be either 0 or 1, depending on whether 'a'
+| is zero or nonzero.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
+INLINE uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )
+{
+    return
+        (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
+}
+#else
+uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist );
+#endif
+#endif
+
+/*----------------------------------------------------------------------------
+| A constant table that translates an 8-bit unsigned integer (the array index)
+| into the number of leading 0 bits before the most-significant 1 of that
+| integer.  For integer zero (index 0), the corresponding table element is 8.
+*----------------------------------------------------------------------------*/
+extern const uint_least8_t softfloat_countLeadingZeros8[256];
+
+#ifndef softfloat_countLeadingZeros16
+/*----------------------------------------------------------------------------
+| Returns the number of leading 0 bits before the most-significant 1 bit of
+| 'a'.  If 'a' is zero, 16 is returned.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
+{
+    uint_fast8_t count = 8;
+    if ( 0x100 <= a ) {
+        count = 0;
+        a >>= 8;
+    }
+    count += softfloat_countLeadingZeros8[a];
+    return count;
+}
+#else
+uint_fast8_t softfloat_countLeadingZeros16( uint16_t a );
+#endif
+#endif
+
+#ifndef softfloat_countLeadingZeros32
+/*----------------------------------------------------------------------------
+| Returns the number of leading 0 bits before the most-significant 1 bit of
+| 'a'.  If 'a' is zero, 32 is returned.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
+INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )
+{
+    uint_fast8_t count = 0;
+    if ( a < 0x10000 ) {
+        count = 16;
+        a <<= 16;
+    }
+    if ( a < 0x1000000 ) {
+        count += 8;
+        a <<= 8;
+    }
+    count += softfloat_countLeadingZeros8[a>>24];
+    return count;
+}
+#else
+uint_fast8_t softfloat_countLeadingZeros32( uint32_t a );
+#endif
+#endif
+
+#ifndef softfloat_countLeadingZeros64
+/*----------------------------------------------------------------------------
+| Returns the number of leading 0 bits before the most-significant 1 bit of
+| 'a'.  If 'a' is zero, 64 is returned.
+*----------------------------------------------------------------------------*/
+uint_fast8_t softfloat_countLeadingZeros64( uint64_t a );
+#endif
+
+extern const uint16_t softfloat_approxRecip_1k0s[16];
+extern const uint16_t softfloat_approxRecip_1k1s[16];
+
+#ifndef softfloat_approxRecip32_1
+/*----------------------------------------------------------------------------
+| Returns an approximation to the reciprocal of the number represented by 'a',
+| where 'a' is interpreted as an unsigned fixed-point number with one integer
+| bit and 31 fraction bits.  The 'a' input must be "normalized", meaning that
+| its most-significant bit (bit 31) must be 1.  Thus, if A is the value of
+| the fixed-point interpretation of 'a', then 1 <= A < 2.  The returned value
+| is interpreted as a pure unsigned fraction, having no integer bits and 32
+| fraction bits.  The approximation returned is never greater than the true
+| reciprocal 1/A, and it differs from the true reciprocal by at most 2.006 ulp
+| (units in the last place).
+*----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_FAST_DIV64TO32
+#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a)))
+#else
+uint32_t softfloat_approxRecip32_1( uint32_t a );
+#endif
+#endif
+
+extern const uint16_t softfloat_approxRecipSqrt_1k0s[16];
+extern const uint16_t softfloat_approxRecipSqrt_1k1s[16];
+
+#ifndef softfloat_approxRecipSqrt32_1
+/*----------------------------------------------------------------------------
+| Returns an approximation to the reciprocal of the square root of the number
+| represented by 'a', where 'a' is interpreted as an unsigned fixed-point
+| number either with one integer bit and 31 fraction bits or with two integer
+| bits and 30 fraction bits.  The format of 'a' is determined by 'oddExpA',
+| which must be either 0 or 1.  If 'oddExpA' is 1, 'a' is interpreted as
+| having one integer bit, and if 'oddExpA' is 0, 'a' is interpreted as having
+| two integer bits.  The 'a' input must be "normalized", meaning that its
+| most-significant bit (bit 31) must be 1.  Thus, if A is the value of the
+| fixed-point interpretation of 'a', it follows that 1 <= A < 2 when 'oddExpA'
+| is 1, and 2 <= A < 4 when 'oddExpA' is 0.
+|   The returned value is interpreted as a pure unsigned fraction, having
+| no integer bits and 32 fraction bits.  The approximation returned is never
+| greater than the true reciprocal 1/sqrt(A), and it differs from the true
+| reciprocal by at most 2.06 ulp (units in the last place).  The approximation
+| returned is also always within the range 0.5 to 1; thus, the most-
+| significant bit of the result is always set.
+*----------------------------------------------------------------------------*/
+uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );
+#endif
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is
+| defined.
+*----------------------------------------------------------------------------*/
+
+#ifndef softfloat_eq128
+/*----------------------------------------------------------------------------
+| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
+| and 'a0' is equal to the 128-bit unsigned integer formed by concatenating
+| 'b64' and 'b0'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
+INLINE
+bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+    { return (a64 == b64) && (a0 == b0); }
+#else
+bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+#endif
+#endif
+
+#ifndef softfloat_le128
+/*----------------------------------------------------------------------------
+| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
+| and 'a0' is less than or equal to the 128-bit unsigned integer formed by
+| concatenating 'b64' and 'b0'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+    { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
+#else
+bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+#endif
+#endif
+
+#ifndef softfloat_lt128
+/*----------------------------------------------------------------------------
+| Returns true if the 128-bit unsigned integer formed by concatenating 'a64'
+| and 'a0' is less than the 128-bit unsigned integer formed by concatenating
+| 'b64' and 'b0'.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+    { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
+#else
+bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftLeft128
+/*----------------------------------------------------------------------------
+| Shifts the 128 bits formed by concatenating 'a64' and 'a0' left by the
+| number of bits given in 'dist', which must be in the range 1 to 63.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+struct uint128
+ softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    struct uint128 z;
+    z.v64 = a64<<dist | a0>>(-dist & 63);
+    z.v0 = a0<<dist;
+    return z;
+}
+#else
+struct uint128
+ softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftRight128
+/*----------------------------------------------------------------------------
+| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
+| number of bits given in 'dist', which must be in the range 1 to 63.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+struct uint128
+ softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    struct uint128 z;
+    z.v64 = a64>>dist;
+    z.v0 = a64<<(-dist & 63) | a0>>dist;
+    return z;
+}
+#else
+struct uint128
+ softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftRightJam64Extra
+/*----------------------------------------------------------------------------
+| This function is the same as 'softfloat_shiftRightJam64Extra' (below),
+| except that 'dist' must be in the range 1 to 63.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+struct uint64_extra
+ softfloat_shortShiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast8_t dist )
+{
+    struct uint64_extra z;
+    z.v = a>>dist;
+    z.extra = a<<(-dist & 63) | (extra != 0);
+    return z;
+}
+#else
+struct uint64_extra
+ softfloat_shortShiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftRightJam128
+/*----------------------------------------------------------------------------
+| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
+| number of bits given in 'dist', which must be in the range 1 to 63.  If any
+| nonzero bits are shifted off, they are "jammed" into the least-significant
+| bit of the shifted value by setting the least-significant bit to 1.  This
+| shifted-and-jammed value is returned.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
+INLINE
+struct uint128
+ softfloat_shortShiftRightJam128(
+     uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    uint_fast8_t negDist = -dist;
+    struct uint128 z;
+    z.v64 = a64>>dist;
+    z.v0 =
+        a64<<(negDist & 63) | a0>>dist
+            | ((uint64_t) (a0<<(negDist & 63)) != 0);
+    return z;
+}
+#else
+struct uint128
+ softfloat_shortShiftRightJam128(
+     uint64_t a64, uint64_t a0, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftRightJam128Extra
+/*----------------------------------------------------------------------------
+| This function is the same as 'softfloat_shiftRightJam128Extra' (below),
+| except that 'dist' must be in the range 1 to 63.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
+INLINE
+struct uint128_extra
+ softfloat_shortShiftRightJam128Extra(
+     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )
+{
+    uint_fast8_t negDist = -dist;
+    struct uint128_extra z;
+    z.v.v64 = a64>>dist;
+    z.v.v0 = a64<<(negDist & 63) | a0>>dist;
+    z.extra = a0<<(negDist & 63) | (extra != 0);
+    return z;
+}
+#else
+struct uint128_extra
+ softfloat_shortShiftRightJam128Extra(
+     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shiftRightJam64Extra
+/*----------------------------------------------------------------------------
+| Shifts the 128 bits formed by concatenating 'a' and 'extra' right by 64
+| _plus_ the number of bits given in 'dist', which must not be zero.  This
+| shifted value is at most 64 nonzero bits and is returned in the 'v' field
+| of the 'struct uint64_extra' result.  The 64-bit 'extra' field of the result
+| contains a value formed as follows from the bits that were shifted off:  The
+| _last_ bit shifted off is the most-significant bit of the 'extra' field, and
+| the other 63 bits of the 'extra' field are all zero if and only if _all_but_
+| _the_last_ bits shifted off were all zero.
+|   (This function makes more sense if 'a' and 'extra' are considered to form
+| an unsigned fixed-point number with binary point between 'a' and 'extra'.
+| This fixed-point value is shifted right by the number of bits given in
+| 'dist', and the integer part of this shifted value is returned in the 'v'
+| field of the result.  The fractional part of the shifted value is modified
+| as described above and returned in the 'extra' field of the result.)
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
+INLINE
+struct uint64_extra
+ softfloat_shiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast32_t dist )
+{
+    struct uint64_extra z;
+    if ( dist < 64 ) {
+        z.v = a>>dist;
+        z.extra = a<<(-dist & 63);
+    } else {
+        z.v = 0;
+        z.extra = (dist == 64) ? a : (a != 0);
+    }
+    z.extra |= (extra != 0);
+    return z;
+}
+#else
+struct uint64_extra
+ softfloat_shiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast32_t dist );
+#endif
+#endif
+
+#ifndef softfloat_shiftRightJam128
+/*----------------------------------------------------------------------------
+| Shifts the 128 bits formed by concatenating 'a64' and 'a0' right by the
+| number of bits given in 'dist', which must not be zero.  If any nonzero bits
+| are shifted off, they are "jammed" into the least-significant bit of the
+| shifted value by setting the least-significant bit to 1.  This shifted-and-
+| jammed value is returned.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
+| greater than 128, the result will be either 0 or 1, depending on whether the
+| original 128 bits are all zeros.
+*----------------------------------------------------------------------------*/
+struct uint128
+ softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist );
+#endif
+
+#ifndef softfloat_shiftRightJam128Extra
+/*----------------------------------------------------------------------------
+| Shifts the 192 bits formed by concatenating 'a64', 'a0', and 'extra' right
+| by 64 _plus_ the number of bits given in 'dist', which must not be zero.
+| This shifted value is at most 128 nonzero bits and is returned in the 'v'
+| field of the 'struct uint128_extra' result.  The 64-bit 'extra' field of the
+| result contains a value formed as follows from the bits that were shifted
+| off:  The _last_ bit shifted off is the most-significant bit of the 'extra'
+| field, and the other 63 bits of the 'extra' field are all zero if and only
+| if _all_but_the_last_ bits shifted off were all zero.
+|   (This function makes more sense if 'a64', 'a0', and 'extra' are considered
+| to form an unsigned fixed-point number with binary point between 'a0' and
+| 'extra'.  This fixed-point value is shifted right by the number of bits
+| given in 'dist', and the integer part of this shifted value is returned
+| in the 'v' field of the result.  The fractional part of the shifted value
+| is modified as described above and returned in the 'extra' field of the
+| result.)
+*----------------------------------------------------------------------------*/
+struct uint128_extra
+ softfloat_shiftRightJam128Extra(
+     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist );
+#endif
+
+#ifndef softfloat_shiftRightJam256M
+/*----------------------------------------------------------------------------
+| Shifts the 256-bit unsigned integer pointed to by 'aPtr' right by the number
+| of bits given in 'dist', which must not be zero.  If any nonzero bits are
+| shifted off, they are "jammed" into the least-significant bit of the shifted
+| value by setting the least-significant bit to 1.  This shifted-and-jammed
+| value is stored at the location pointed to by 'zPtr'.  Each of 'aPtr' and
+| 'zPtr' points to an array of four 64-bit elements that concatenate in the
+| platform's normal endian order to form a 256-bit integer.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist'
+| is greater than 256, the stored result will be either 0 or 1, depending on
+| whether the original 256 bits are all zeros.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shiftRightJam256M(
+     const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr );
+#endif
+
+#ifndef softfloat_add128
+/*----------------------------------------------------------------------------
+| Returns the sum of the 128-bit integer formed by concatenating 'a64' and
+| 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'.  The
+| addition is modulo 2^128, so any carry out is lost.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+struct uint128
+ softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+    struct uint128 z;
+    z.v0 = a0 + b0;
+    z.v64 = a64 + b64 + (z.v0 < a0);
+    return z;
+}
+#else
+struct uint128
+ softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+#endif
+#endif
+
+#ifndef softfloat_add256M
+/*----------------------------------------------------------------------------
+| Adds the two 256-bit integers pointed to by 'aPtr' and 'bPtr'.  The addition
+| is modulo 2^256, so any carry out is lost.  The sum is stored at the
+| location pointed to by 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to
+| an array of four 64-bit elements that concatenate in the platform's normal
+| endian order to form a 256-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_add256M(
+     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
+#endif
+
+#ifndef softfloat_sub128
+/*----------------------------------------------------------------------------
+| Returns the difference of the 128-bit integer formed by concatenating 'a64'
+| and 'a0' and the 128-bit integer formed by concatenating 'b64' and 'b0'.
+| The subtraction is modulo 2^128, so any borrow out (carry out) is lost.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+struct uint128
+ softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+    struct uint128 z;
+    z.v0 = a0 - b0;
+    z.v64 = a64 - b64;
+    z.v64 -= (a0 < b0);
+    return z;
+}
+#else
+struct uint128
+ softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+#endif
+#endif
+
+#ifndef softfloat_sub256M
+/*----------------------------------------------------------------------------
+| Subtracts the 256-bit integer pointed to by 'bPtr' from the 256-bit integer
+| pointed to by 'aPtr'.  The addition is modulo 2^256, so any borrow out
+| (carry out) is lost.  The difference is stored at the location pointed to
+| by 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to an array of four
+| 64-bit elements that concatenate in the platform's normal endian order to
+| form a 256-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_sub256M(
+     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
+#endif
+
+#ifndef softfloat_mul64ByShifted32To128
+/*----------------------------------------------------------------------------
+| Returns the 128-bit product of 'a', 'b', and 2^32.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
+INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )
+{
+    uint_fast64_t mid;
+    struct uint128 z;
+    mid = (uint_fast64_t) (uint32_t) a * b;
+    z.v0 = mid<<32;
+    z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);
+    return z;
+}
+#else
+struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b );
+#endif
+#endif
+
+#ifndef softfloat_mul64To128
+/*----------------------------------------------------------------------------
+| Returns the 128-bit product of 'a' and 'b'.
+*----------------------------------------------------------------------------*/
+struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );
+#endif
+
+#ifndef softfloat_mul128By32
+/*----------------------------------------------------------------------------
+| Returns the product of the 128-bit integer formed by concatenating 'a64' and
+| 'a0', multiplied by 'b'.  The multiplication is modulo 2^128; any overflow
+| bits are discarded.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
+INLINE
+struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )
+{
+    struct uint128 z;
+    uint_fast64_t mid;
+    uint_fast32_t carry;
+    z.v0 = a0 * b;
+    mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;
+    carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);
+    z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);
+    return z;
+}
+#else
+struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b );
+#endif
+#endif
+
+#ifndef softfloat_mul128To256M
+/*----------------------------------------------------------------------------
+| Multiplies the 128-bit unsigned integer formed by concatenating 'a64' and
+| 'a0' by the 128-bit unsigned integer formed by concatenating 'b64' and
+| 'b0'.  The 256-bit product is stored at the location pointed to by 'zPtr'.
+| Argument 'zPtr' points to an array of four 64-bit elements that concatenate
+| in the platform's normal endian order to form a 256-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_mul128To256M(
+     uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr );
+#endif
+
+#else
+
+/*----------------------------------------------------------------------------
+| The following functions are needed only when 'SOFTFLOAT_FAST_INT64' is not
+| defined.
+*----------------------------------------------------------------------------*/
+
+#ifndef softfloat_compare96M
+/*----------------------------------------------------------------------------
+| Compares the two 96-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.
+| Returns -1 if the first integer (A) is less than the second (B); returns 0
+| if the two integers are equal; and returns +1 if the first integer (A)
+| is greater than the second (B).  (The result is thus the signum of A - B.)
+| Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that
+| concatenate in the platform's normal endian order to form a 96-bit integer.
+*----------------------------------------------------------------------------*/
+int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr );
+#endif
+
+#ifndef softfloat_compare128M
+/*----------------------------------------------------------------------------
+| Compares the two 128-bit unsigned integers pointed to by 'aPtr' and 'bPtr'.
+| Returns -1 if the first integer (A) is less than the second (B); returns 0
+| if the two integers are equal; and returns +1 if the first integer (A)
+| is greater than the second (B).  (The result is thus the signum of A - B.)
+| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
+| concatenate in the platform's normal endian order to form a 128-bit integer.
+*----------------------------------------------------------------------------*/
+int_fast8_t
+ softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr );
+#endif
+
+#ifndef softfloat_shortShiftLeft64To96M
+/*----------------------------------------------------------------------------
+| Extends 'a' to 96 bits and shifts the value left by the number of bits given
+| in 'dist', which must be in the range 1 to 31.  The result is stored at the
+| location pointed to by 'zPtr'.  Argument 'zPtr' points to an array of three
+| 32-bit elements that concatenate in the platform's normal endian order to
+| form a 96-bit integer.
+*----------------------------------------------------------------------------*/
+#if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
+INLINE
+void
+ softfloat_shortShiftLeft64To96M(
+     uint64_t a, uint_fast8_t dist, uint32_t *zPtr )
+{
+    zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
+    a >>= 32 - dist;
+    zPtr[indexWord( 3, 2 )] = a>>32;
+    zPtr[indexWord( 3, 1 )] = a;
+}
+#else
+void
+ softfloat_shortShiftLeft64To96M(
+     uint64_t a, uint_fast8_t dist, uint32_t *zPtr );
+#endif
+#endif
+
+#ifndef softfloat_shortShiftLeftM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must be in the range 1 to 31.  Any nonzero bits shifted off are lost.  The
+| shifted N-bit result is stored at the location pointed to by 'zPtr'.  Each
+| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements
+| that concatenate in the platform's normal endian order to form an N-bit
+| integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shortShiftLeftM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_shortShiftLeft96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftLeftM' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftLeft96M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shortShiftLeft128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftLeftM' with
+| 'size_words' = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftLeft128M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shortShiftLeft160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftLeftM' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftLeft160M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftLeftM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' left by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must not be zero.  Any nonzero bits shifted off are lost.  The shifted
+| N-bit result is stored at the location pointed to by 'zPtr'.  Each of 'aPtr'
+| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that
+| concatenate in the platform's normal endian order to form an N-bit integer.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
+| greater than N, the stored result will be 0.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shiftLeftM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_shiftLeft96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftLeftM' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftLeft96M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 3, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftLeft128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftLeftM' with
+| 'size_words' = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftLeft128M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 4, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftLeft160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftLeftM' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftLeft160M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 5, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shortShiftRightM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must be in the range 1 to 31.  Any nonzero bits shifted off are lost.  The
+| shifted N-bit result is stored at the location pointed to by 'zPtr'.  Each
+| of 'aPtr' and 'zPtr' points to a 'size_words'-long array of 32-bit elements
+| that concatenate in the platform's normal endian order to form an N-bit
+| integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shortShiftRightM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_shortShiftRight128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftRightM' with
+| 'size_words' = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftRight128M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 4, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shortShiftRight160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftRightM' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftRight160M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 5, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shortShiftRightJamM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must be in the range 1 to 31.  If any nonzero bits are shifted off, they are
+| "jammed" into the least-significant bit of the shifted value by setting the
+| least-significant bit to 1.  This shifted-and-jammed N-bit result is stored
+| at the location pointed to by 'zPtr'.  Each of 'aPtr' and 'zPtr' points
+| to a 'size_words'-long array of 32-bit elements that concatenate in the
+| platform's normal endian order to form an N-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shortShiftRightJamM(
+     uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t * );
+#endif
+
+#ifndef softfloat_shortShiftRightJam160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shortShiftRightJamM' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_shortShiftRightJam160M( aPtr, dist, zPtr ) softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftRightM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must not be zero.  Any nonzero bits shifted off are lost.  The shifted
+| N-bit result is stored at the location pointed to by 'zPtr'.  Each of 'aPtr'
+| and 'zPtr' points to a 'size_words'-long array of 32-bit elements that
+| concatenate in the platform's normal endian order to form an N-bit integer.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
+| greater than N, the stored result will be 0.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shiftRightM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_shiftRight96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftRightM' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftRight96M( aPtr, dist, zPtr ) softfloat_shiftRightM( 3, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftRightJamM
+/*----------------------------------------------------------------------------
+| Shifts the N-bit unsigned integer pointed to by 'aPtr' right by the number
+| of bits given in 'dist', where N = 'size_words' * 32.  The value of 'dist'
+| must not be zero.  If any nonzero bits are shifted off, they are "jammed"
+| into the least-significant bit of the shifted value by setting the least-
+| significant bit to 1.  This shifted-and-jammed N-bit result is stored
+| at the location pointed to by 'zPtr'.  Each of 'aPtr' and 'zPtr' points
+| to a 'size_words'-long array of 32-bit elements that concatenate in the
+| platform's normal endian order to form an N-bit integer.
+|   The value of 'dist' can be arbitrarily large.  In particular, if 'dist'
+| is greater than N, the stored result will be either 0 or 1, depending on
+| whether the original N bits are all zeros.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_shiftRightJamM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_shiftRightJam96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftRightJamM' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftRightJam96M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 3, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftRightJam128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftRightJamM' with
+| 'size_words' = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftRightJam128M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 4, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_shiftRightJam160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_shiftRightJamM' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_shiftRightJam160M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 5, aPtr, dist, zPtr )
+#endif
+
+#ifndef softfloat_addM
+/*----------------------------------------------------------------------------
+| Adds the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =
+| 'size_words' * 32.  The addition is modulo 2^N, so any carry out is lost.
+| The N-bit sum is stored at the location pointed to by 'zPtr'.  Each of
+| 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long array of 32-bit
+| elements that concatenate in the platform's normal endian order to form an
+| N-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_addM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_add96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_addM' with 'size_words'
+| = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_add96M( aPtr, bPtr, zPtr ) softfloat_addM( 3, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_add128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_addM' with 'size_words'
+| = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_add128M( aPtr, bPtr, zPtr ) softfloat_addM( 4, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_add160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_addM' with 'size_words'
+| = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_add160M( aPtr, bPtr, zPtr ) softfloat_addM( 5, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_addCarryM
+/*----------------------------------------------------------------------------
+| Adds the two N-bit unsigned integers pointed to by 'aPtr' and 'bPtr', where
+| N = 'size_words' * 32, plus 'carry', which must be either 0 or 1.  The N-bit
+| sum (modulo 2^N) is stored at the location pointed to by 'zPtr', and any
+| carry out is returned as the result.  Each of 'aPtr', 'bPtr', and 'zPtr'
+| points to a 'size_words'-long array of 32-bit elements that concatenate in
+| the platform's normal endian order to form an N-bit integer.
+*----------------------------------------------------------------------------*/
+uint_fast8_t
+ softfloat_addCarryM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint_fast8_t carry,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_addComplCarryM
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_addCarryM', except that
+| the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed
+| before the addition.
+*----------------------------------------------------------------------------*/
+uint_fast8_t
+ softfloat_addComplCarryM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint_fast8_t carry,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_addComplCarry96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_addComplCarryM' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_addComplCarry96M( aPtr, bPtr, carry, zPtr ) softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr )
+#endif
+
+#ifndef softfloat_negXM
+/*----------------------------------------------------------------------------
+| Replaces the N-bit unsigned integer pointed to by 'zPtr' by the
+| 2s-complement of itself, where N = 'size_words' * 32.  Argument 'zPtr'
+| points to a 'size_words'-long array of 32-bit elements that concatenate in
+| the platform's normal endian order to form an N-bit integer.
+*----------------------------------------------------------------------------*/
+void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
+#endif
+
+#ifndef softfloat_negX96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_negXM' with 'size_words'
+| = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_negX96M( zPtr ) softfloat_negXM( 3, zPtr )
+#endif
+
+#ifndef softfloat_negX128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_negXM' with 'size_words'
+| = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_negX128M( zPtr ) softfloat_negXM( 4, zPtr )
+#endif
+
+#ifndef softfloat_negX160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_negXM' with 'size_words'
+| = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_negX160M( zPtr ) softfloat_negXM( 5, zPtr )
+#endif
+
+#ifndef softfloat_negX256M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_negXM' with 'size_words'
+| = 8 (N = 256).
+*----------------------------------------------------------------------------*/
+#define softfloat_negX256M( zPtr ) softfloat_negXM( 8, zPtr )
+#endif
+
+#ifndef softfloat_sub1XM
+/*----------------------------------------------------------------------------
+| Subtracts 1 from the N-bit integer pointed to by 'zPtr', where N =
+| 'size_words' * 32.  The subtraction is modulo 2^N, so any borrow out (carry
+| out) is lost.  Argument 'zPtr' points to a 'size_words'-long array of 32-bit
+| elements that concatenate in the platform's normal endian order to form an
+| N-bit integer.
+*----------------------------------------------------------------------------*/
+void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
+#endif
+
+#ifndef softfloat_sub1X96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
+| = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_sub1X96M( zPtr ) softfloat_sub1XM( 3, zPtr )
+#endif
+
+#ifndef softfloat_sub1X160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
+| = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_sub1X160M( zPtr ) softfloat_sub1XM( 5, zPtr )
+#endif
+
+#ifndef softfloat_subM
+/*----------------------------------------------------------------------------
+| Subtracts the two N-bit integers pointed to by 'aPtr' and 'bPtr', where N =
+| 'size_words' * 32.  The subtraction is modulo 2^N, so any borrow out (carry
+| out) is lost.  The N-bit difference is stored at the location pointed to by
+| 'zPtr'.  Each of 'aPtr', 'bPtr', and 'zPtr' points to a 'size_words'-long
+| array of 32-bit elements that concatenate in the platform's normal endian
+| order to form an N-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_subM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_sub96M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_subM' with 'size_words'
+| = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_sub96M( aPtr, bPtr, zPtr ) softfloat_subM( 3, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_sub128M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_subM' with 'size_words'
+| = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_sub128M( aPtr, bPtr, zPtr ) softfloat_subM( 4, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_sub160M
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_subM' with 'size_words'
+| = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_sub160M( aPtr, bPtr, zPtr ) softfloat_subM( 5, aPtr, bPtr, zPtr )
+#endif
+
+#ifndef softfloat_mul64To128M
+/*----------------------------------------------------------------------------
+| Multiplies 'a' and 'b' and stores the 128-bit product at the location
+| pointed to by 'zPtr'.  Argument 'zPtr' points to an array of four 32-bit
+| elements that concatenate in the platform's normal endian order to form a
+| 128-bit integer.
+*----------------------------------------------------------------------------*/
+void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr );
+#endif
+
+#ifndef softfloat_mul128MTo256M
+/*----------------------------------------------------------------------------
+| Multiplies the two 128-bit unsigned integers pointed to by 'aPtr' and
+| 'bPtr', and stores the 256-bit product at the location pointed to by 'zPtr'.
+| Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
+| concatenate in the platform's normal endian order to form a 128-bit integer.
+| Argument 'zPtr' points to an array of eight 32-bit elements that concatenate
+| to form a 256-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_mul128MTo256M(
+     const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr );
+#endif
+
+#ifndef softfloat_remStepMBy32
+/*----------------------------------------------------------------------------
+| Performs a "remainder reduction step" as follows:  Arguments 'remPtr' and
+| 'bPtr' both point to N-bit unsigned integers, where N = 'size_words' * 32.
+| Defining R and B as the values of those integers, the expression (R<<'dist')
+| - B * q is computed modulo 2^N, and the N-bit result is stored at the
+| location pointed to by 'zPtr'.  Each of 'remPtr', 'bPtr', and 'zPtr' points
+| to a 'size_words'-long array of 32-bit elements that concatenate in the
+| platform's normal endian order to form an N-bit integer.
+*----------------------------------------------------------------------------*/
+void
+ softfloat_remStepMBy32(
+     uint_fast8_t size_words,
+     const uint32_t *remPtr,
+     uint_fast8_t dist,
+     const uint32_t *bPtr,
+     uint32_t q,
+     uint32_t *zPtr
+ );
+#endif
+
+#ifndef softfloat_remStep96MBy32
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_remStepMBy32' with
+| 'size_words' = 3 (N = 96).
+*----------------------------------------------------------------------------*/
+#define softfloat_remStep96MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr )
+#endif
+
+#ifndef softfloat_remStep128MBy32
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_remStepMBy32' with
+| 'size_words' = 4 (N = 128).
+*----------------------------------------------------------------------------*/
+#define softfloat_remStep128MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr )
+#endif
+
+#ifndef softfloat_remStep160MBy32
+/*----------------------------------------------------------------------------
+| This function or macro is the same as 'softfloat_remStepMBy32' with
+| 'size_words' = 5 (N = 160).
+*----------------------------------------------------------------------------*/
+#define softfloat_remStep160MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr )
+#endif
+
+#endif
+
+#endif
+
diff --git a/softfloat/source/include/softfloat.h b/softfloat/source/include/softfloat.h
index f07211e..bf5014b 100644
--- a/softfloat/source/include/softfloat.h
+++ b/softfloat/source/include/softfloat.h
@@ -1,361 +1,379 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-/*============================================================================
-| Note:  If SoftFloat is made available as a general library for programs to
-| use, it is strongly recommended that a platform-specific version of this
-| header, "softfloat.h", be created that folds in "softfloat_types.h" and that
-| eliminates all dependencies on compile-time macros.
-*============================================================================*/
-
-#ifndef softfloat_h
-#define softfloat_h 1
-
-#include "softfloat_types.h"
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifndef THREAD_LOCAL
-#define THREAD_LOCAL
-#endif
-
-/*----------------------------------------------------------------------------
-| Software floating-point underflow tininess-detection mode.
-*----------------------------------------------------------------------------*/
-extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
-enum { softfloat_tininess_beforeRounding = 0, softfloat_tininess_afterRounding = 1 };
-
-/*----------------------------------------------------------------------------
-| Software floating-point rounding mode.  (Mode "odd" is supported only if
-| SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)
-*----------------------------------------------------------------------------*/
-extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
-enum {
-    softfloat_round_near_even = 0,
-    softfloat_round_minMag = 1,
-    softfloat_round_min = 2,
-    softfloat_round_max = 3,
-    softfloat_round_near_maxMag = 4,
-    softfloat_round_odd = 6
-};
-
-/*----------------------------------------------------------------------------
-| Software floating-point exception flags.
-*----------------------------------------------------------------------------*/
-extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
-enum {
-    softfloat_flag_inexact = 1,
-    softfloat_flag_underflow = 2,
-    softfloat_flag_overflow = 4,
-    softfloat_flag_infinite = 8,
-    softfloat_flag_invalid = 16
-};
-
-/*----------------------------------------------------------------------------
-| Routine to raise any or all of the software floating-point exception flags.
-*----------------------------------------------------------------------------*/
-void softfloat_raiseFlags(uint_fast8_t);
-
-/*----------------------------------------------------------------------------
-| Integer-to-floating-point conversion routines.
-*----------------------------------------------------------------------------*/
-float16_t ui32_to_f16(uint32_t);
-float32_t ui32_to_f32(uint32_t);
-float64_t ui32_to_f64(uint32_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui32_to_extF80(uint32_t);
-float128_t ui32_to_f128(uint32_t);
-#endif
-void ui32_to_extF80M(uint32_t, extFloat80_t*);
-void ui32_to_f128M(uint32_t, float128_t*);
-float16_t ui64_to_f16(uint64_t);
-float32_t ui64_to_f32(uint64_t);
-float64_t ui64_to_f64(uint64_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui64_to_extF80(uint64_t);
-float128_t ui64_to_f128(uint64_t);
-#endif
-void ui64_to_extF80M(uint64_t, extFloat80_t*);
-void ui64_to_f128M(uint64_t, float128_t*);
-float16_t i32_to_f16(int32_t);
-float32_t i32_to_f32(int32_t);
-float64_t i32_to_f64(int32_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i32_to_extF80(int32_t);
-float128_t i32_to_f128(int32_t);
-#endif
-void i32_to_extF80M(int32_t, extFloat80_t*);
-void i32_to_f128M(int32_t, float128_t*);
-float16_t i64_to_f16(int64_t);
-float32_t i64_to_f32(int64_t);
-float64_t i64_to_f64(int64_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i64_to_extF80(int64_t);
-float128_t i64_to_f128(int64_t);
-#endif
-void i64_to_extF80M(int64_t, extFloat80_t*);
-void i64_to_f128M(int64_t, float128_t*);
-
-/*----------------------------------------------------------------------------
-| 16-bit (half-precision) floating-point operations.
-*----------------------------------------------------------------------------*/
-uint_fast32_t f16_to_ui32(float16_t, uint_fast8_t, bool);
-uint_fast64_t f16_to_ui64(float16_t, uint_fast8_t, bool);
-int_fast32_t f16_to_i32(float16_t, uint_fast8_t, bool);
-int_fast64_t f16_to_i64(float16_t, uint_fast8_t, bool);
-uint_fast32_t f16_to_ui32_r_minMag(float16_t, bool);
-uint_fast64_t f16_to_ui64_r_minMag(float16_t, bool);
-int_fast32_t f16_to_i32_r_minMag(float16_t, bool);
-int_fast64_t f16_to_i64_r_minMag(float16_t, bool);
-float32_t f16_to_f32(float16_t);
-float64_t f16_to_f64(float16_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f16_to_extF80(float16_t);
-float128_t f16_to_f128(float16_t);
-#endif
-void f16_to_extF80M(float16_t, extFloat80_t*);
-void f16_to_f128M(float16_t, float128_t*);
-float16_t f16_roundToInt(float16_t, uint_fast8_t, bool);
-float16_t f16_add(float16_t, float16_t);
-float16_t f16_sub(float16_t, float16_t);
-float16_t f16_mul(float16_t, float16_t);
-float16_t f16_mulAdd(float16_t, float16_t, float16_t);
-float16_t f16_div(float16_t, float16_t);
-float16_t f16_rem(float16_t, float16_t);
-float16_t f16_sqrt(float16_t);
-bool f16_eq(float16_t, float16_t);
-bool f16_le(float16_t, float16_t);
-bool f16_lt(float16_t, float16_t);
-bool f16_eq_signaling(float16_t, float16_t);
-bool f16_le_quiet(float16_t, float16_t);
-bool f16_lt_quiet(float16_t, float16_t);
-bool f16_isSignalingNaN(float16_t);
-
-/*----------------------------------------------------------------------------
-| 32-bit (single-precision) floating-point operations.
-*----------------------------------------------------------------------------*/
-uint_fast32_t f32_to_ui32(float32_t, uint_fast8_t, bool);
-uint_fast64_t f32_to_ui64(float32_t, uint_fast8_t, bool);
-int_fast32_t f32_to_i32(float32_t, uint_fast8_t, bool);
-int_fast64_t f32_to_i64(float32_t, uint_fast8_t, bool);
-uint_fast32_t f32_to_ui32_r_minMag(float32_t, bool);
-uint_fast64_t f32_to_ui64_r_minMag(float32_t, bool);
-int_fast32_t f32_to_i32_r_minMag(float32_t, bool);
-int_fast64_t f32_to_i64_r_minMag(float32_t, bool);
-float16_t f32_to_f16(float32_t);
-float64_t f32_to_f64(float32_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f32_to_extF80(float32_t);
-float128_t f32_to_f128(float32_t);
-#endif
-void f32_to_extF80M(float32_t, extFloat80_t*);
-void f32_to_f128M(float32_t, float128_t*);
-float32_t f32_roundToInt(float32_t, uint_fast8_t, bool);
-float32_t f32_add(float32_t, float32_t);
-float32_t f32_sub(float32_t, float32_t);
-float32_t f32_mul(float32_t, float32_t);
-float32_t f32_mulAdd(float32_t, float32_t, float32_t);
-float32_t f32_div(float32_t, float32_t);
-float32_t f32_rem(float32_t, float32_t);
-float32_t f32_sqrt(float32_t);
-bool f32_eq(float32_t, float32_t);
-bool f32_le(float32_t, float32_t);
-bool f32_lt(float32_t, float32_t);
-bool f32_eq_signaling(float32_t, float32_t);
-bool f32_le_quiet(float32_t, float32_t);
-bool f32_lt_quiet(float32_t, float32_t);
-bool f32_isSignalingNaN(float32_t);
-
-/*----------------------------------------------------------------------------
-| 64-bit (double-precision) floating-point operations.
-*----------------------------------------------------------------------------*/
-uint_fast32_t f64_to_ui32(float64_t, uint_fast8_t, bool);
-uint_fast64_t f64_to_ui64(float64_t, uint_fast8_t, bool);
-int_fast32_t f64_to_i32(float64_t, uint_fast8_t, bool);
-int_fast64_t f64_to_i64(float64_t, uint_fast8_t, bool);
-uint_fast32_t f64_to_ui32_r_minMag(float64_t, bool);
-uint_fast64_t f64_to_ui64_r_minMag(float64_t, bool);
-int_fast32_t f64_to_i32_r_minMag(float64_t, bool);
-int_fast64_t f64_to_i64_r_minMag(float64_t, bool);
-float16_t f64_to_f16(float64_t);
-float32_t f64_to_f32(float64_t);
-#ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f64_to_extF80(float64_t);
-float128_t f64_to_f128(float64_t);
-#endif
-void f64_to_extF80M(float64_t, extFloat80_t*);
-void f64_to_f128M(float64_t, float128_t*);
-float64_t f64_roundToInt(float64_t, uint_fast8_t, bool);
-float64_t f64_add(float64_t, float64_t);
-float64_t f64_sub(float64_t, float64_t);
-float64_t f64_mul(float64_t, float64_t);
-float64_t f64_mulAdd(float64_t, float64_t, float64_t);
-float64_t f64_div(float64_t, float64_t);
-float64_t f64_rem(float64_t, float64_t);
-float64_t f64_sqrt(float64_t);
-bool f64_eq(float64_t, float64_t);
-bool f64_le(float64_t, float64_t);
-bool f64_lt(float64_t, float64_t);
-bool f64_eq_signaling(float64_t, float64_t);
-bool f64_le_quiet(float64_t, float64_t);
-bool f64_lt_quiet(float64_t, float64_t);
-bool f64_isSignalingNaN(float64_t);
-
-/*----------------------------------------------------------------------------
-| Rounding precision for 80-bit extended double-precision floating-point.
-| Valid values are 32, 64, and 80.
-*----------------------------------------------------------------------------*/
-extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
-
-/*----------------------------------------------------------------------------
-| 80-bit extended double-precision floating-point operations.
-*----------------------------------------------------------------------------*/
-#ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t extF80_to_ui32(extFloat80_t, uint_fast8_t, bool);
-uint_fast64_t extF80_to_ui64(extFloat80_t, uint_fast8_t, bool);
-int_fast32_t extF80_to_i32(extFloat80_t, uint_fast8_t, bool);
-int_fast64_t extF80_to_i64(extFloat80_t, uint_fast8_t, bool);
-uint_fast32_t extF80_to_ui32_r_minMag(extFloat80_t, bool);
-uint_fast64_t extF80_to_ui64_r_minMag(extFloat80_t, bool);
-int_fast32_t extF80_to_i32_r_minMag(extFloat80_t, bool);
-int_fast64_t extF80_to_i64_r_minMag(extFloat80_t, bool);
-float16_t extF80_to_f16(extFloat80_t);
-float32_t extF80_to_f32(extFloat80_t);
-float64_t extF80_to_f64(extFloat80_t);
-float128_t extF80_to_f128(extFloat80_t);
-extFloat80_t extF80_roundToInt(extFloat80_t, uint_fast8_t, bool);
-extFloat80_t extF80_add(extFloat80_t, extFloat80_t);
-extFloat80_t extF80_sub(extFloat80_t, extFloat80_t);
-extFloat80_t extF80_mul(extFloat80_t, extFloat80_t);
-extFloat80_t extF80_div(extFloat80_t, extFloat80_t);
-extFloat80_t extF80_rem(extFloat80_t, extFloat80_t);
-extFloat80_t extF80_sqrt(extFloat80_t);
-bool extF80_eq(extFloat80_t, extFloat80_t);
-bool extF80_le(extFloat80_t, extFloat80_t);
-bool extF80_lt(extFloat80_t, extFloat80_t);
-bool extF80_eq_signaling(extFloat80_t, extFloat80_t);
-bool extF80_le_quiet(extFloat80_t, extFloat80_t);
-bool extF80_lt_quiet(extFloat80_t, extFloat80_t);
-bool extF80_isSignalingNaN(extFloat80_t);
-#endif
-uint_fast32_t extF80M_to_ui32(const extFloat80_t*, uint_fast8_t, bool);
-uint_fast64_t extF80M_to_ui64(const extFloat80_t*, uint_fast8_t, bool);
-int_fast32_t extF80M_to_i32(const extFloat80_t*, uint_fast8_t, bool);
-int_fast64_t extF80M_to_i64(const extFloat80_t*, uint_fast8_t, bool);
-uint_fast32_t extF80M_to_ui32_r_minMag(const extFloat80_t*, bool);
-uint_fast64_t extF80M_to_ui64_r_minMag(const extFloat80_t*, bool);
-int_fast32_t extF80M_to_i32_r_minMag(const extFloat80_t*, bool);
-int_fast64_t extF80M_to_i64_r_minMag(const extFloat80_t*, bool);
-float16_t extF80M_to_f16(const extFloat80_t*);
-float32_t extF80M_to_f32(const extFloat80_t*);
-float64_t extF80M_to_f64(const extFloat80_t*);
-void extF80M_to_f128M(const extFloat80_t*, float128_t*);
-void extF80M_roundToInt(const extFloat80_t*, uint_fast8_t, bool, extFloat80_t*);
-void extF80M_add(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
-void extF80M_sub(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
-void extF80M_mul(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
-void extF80M_div(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
-void extF80M_rem(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
-void extF80M_sqrt(const extFloat80_t*, extFloat80_t*);
-bool extF80M_eq(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_le(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_lt(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_eq_signaling(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_le_quiet(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_lt_quiet(const extFloat80_t*, const extFloat80_t*);
-bool extF80M_isSignalingNaN(const extFloat80_t*);
-
-/*----------------------------------------------------------------------------
-| 128-bit (quadruple-precision) floating-point operations.
-*----------------------------------------------------------------------------*/
-#ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t f128_to_ui32(float128_t, uint_fast8_t, bool);
-uint_fast64_t f128_to_ui64(float128_t, uint_fast8_t, bool);
-int_fast32_t f128_to_i32(float128_t, uint_fast8_t, bool);
-int_fast64_t f128_to_i64(float128_t, uint_fast8_t, bool);
-uint_fast32_t f128_to_ui32_r_minMag(float128_t, bool);
-uint_fast64_t f128_to_ui64_r_minMag(float128_t, bool);
-int_fast32_t f128_to_i32_r_minMag(float128_t, bool);
-int_fast64_t f128_to_i64_r_minMag(float128_t, bool);
-float16_t f128_to_f16(float128_t);
-float32_t f128_to_f32(float128_t);
-float64_t f128_to_f64(float128_t);
-extFloat80_t f128_to_extF80(float128_t);
-float128_t f128_roundToInt(float128_t, uint_fast8_t, bool);
-float128_t f128_add(float128_t, float128_t);
-float128_t f128_sub(float128_t, float128_t);
-float128_t f128_mul(float128_t, float128_t);
-float128_t f128_mulAdd(float128_t, float128_t, float128_t);
-float128_t f128_div(float128_t, float128_t);
-float128_t f128_rem(float128_t, float128_t);
-float128_t f128_sqrt(float128_t);
-bool f128_eq(float128_t, float128_t);
-bool f128_le(float128_t, float128_t);
-bool f128_lt(float128_t, float128_t);
-bool f128_eq_signaling(float128_t, float128_t);
-bool f128_le_quiet(float128_t, float128_t);
-bool f128_lt_quiet(float128_t, float128_t);
-bool f128_isSignalingNaN(float128_t);
-#endif
-uint_fast32_t f128M_to_ui32(const float128_t*, uint_fast8_t, bool);
-uint_fast64_t f128M_to_ui64(const float128_t*, uint_fast8_t, bool);
-int_fast32_t f128M_to_i32(const float128_t*, uint_fast8_t, bool);
-int_fast64_t f128M_to_i64(const float128_t*, uint_fast8_t, bool);
-uint_fast32_t f128M_to_ui32_r_minMag(const float128_t*, bool);
-uint_fast64_t f128M_to_ui64_r_minMag(const float128_t*, bool);
-int_fast32_t f128M_to_i32_r_minMag(const float128_t*, bool);
-int_fast64_t f128M_to_i64_r_minMag(const float128_t*, bool);
-float16_t f128M_to_f16(const float128_t*);
-float32_t f128M_to_f32(const float128_t*);
-float64_t f128M_to_f64(const float128_t*);
-void f128M_to_extF80M(const float128_t*, extFloat80_t*);
-void f128M_roundToInt(const float128_t*, uint_fast8_t, bool, float128_t*);
-void f128M_add(const float128_t*, const float128_t*, float128_t*);
-void f128M_sub(const float128_t*, const float128_t*, float128_t*);
-void f128M_mul(const float128_t*, const float128_t*, float128_t*);
-void f128M_mulAdd(const float128_t*, const float128_t*, const float128_t*, float128_t*);
-void f128M_div(const float128_t*, const float128_t*, float128_t*);
-void f128M_rem(const float128_t*, const float128_t*, float128_t*);
-void f128M_sqrt(const float128_t*, float128_t*);
-bool f128M_eq(const float128_t*, const float128_t*);
-bool f128M_le(const float128_t*, const float128_t*);
-bool f128M_lt(const float128_t*, const float128_t*);
-bool f128M_eq_signaling(const float128_t*, const float128_t*);
-bool f128M_le_quiet(const float128_t*, const float128_t*);
-bool f128M_lt_quiet(const float128_t*, const float128_t*);
-bool f128M_isSignalingNaN(const float128_t*);
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+
+/*============================================================================
+| Note:  If SoftFloat is made available as a general library for programs to
+| use, it is strongly recommended that a platform-specific version of this
+| header, "softfloat.h", be created that folds in "softfloat_types.h" and that
+| eliminates all dependencies on compile-time macros.
+*============================================================================*/
+
+
+#ifndef softfloat_h
+#define softfloat_h 1
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "softfloat_types.h"
+
+#ifndef THREAD_LOCAL
+#define THREAD_LOCAL
+#endif
+
+/*----------------------------------------------------------------------------
+| Software floating-point underflow tininess-detection mode.
+*----------------------------------------------------------------------------*/
+extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
+enum {
+    softfloat_tininess_beforeRounding = 0,
+    softfloat_tininess_afterRounding  = 1
+};
+
+/*----------------------------------------------------------------------------
+| Software floating-point rounding mode.  (Mode "odd" is supported only if
+| SoftFloat is compiled with macro 'SOFTFLOAT_ROUND_ODD' defined.)
+*----------------------------------------------------------------------------*/
+extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
+enum {
+    softfloat_round_near_even   = 0,
+    softfloat_round_minMag      = 1,
+    softfloat_round_min         = 2,
+    softfloat_round_max         = 3,
+    softfloat_round_near_maxMag = 4,
+    softfloat_round_odd         = 6
+};
+
+/*----------------------------------------------------------------------------
+| Software floating-point exception flags.
+*----------------------------------------------------------------------------*/
+extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
+typedef enum {
+    softfloat_flag_inexact   =  1,
+    softfloat_flag_underflow =  2,
+    softfloat_flag_overflow  =  4,
+    softfloat_flag_infinite  =  8,
+    softfloat_flag_invalid   = 16
+} exceptionFlag_t;
+
+/*----------------------------------------------------------------------------
+| Routine to raise any or all of the software floating-point exception flags.
+*----------------------------------------------------------------------------*/
+void softfloat_raiseFlags( uint_fast8_t );
+
+/*----------------------------------------------------------------------------
+| Integer-to-floating-point conversion routines.
+*----------------------------------------------------------------------------*/
+float16_t ui32_to_f16( uint32_t );
+float32_t ui32_to_f32( uint32_t );
+float64_t ui32_to_f64( uint32_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t ui32_to_extF80( uint32_t );
+float128_t ui32_to_f128( uint32_t );
+#endif
+void ui32_to_extF80M( uint32_t, extFloat80_t * );
+void ui32_to_f128M( uint32_t, float128_t * );
+float16_t ui64_to_f16( uint64_t );
+float32_t ui64_to_f32( uint64_t );
+float64_t ui64_to_f64( uint64_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t ui64_to_extF80( uint64_t );
+float128_t ui64_to_f128( uint64_t );
+#endif
+void ui64_to_extF80M( uint64_t, extFloat80_t * );
+void ui64_to_f128M( uint64_t, float128_t * );
+float16_t i32_to_f16( int32_t );
+float32_t i32_to_f32( int32_t );
+float64_t i32_to_f64( int32_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t i32_to_extF80( int32_t );
+float128_t i32_to_f128( int32_t );
+#endif
+void i32_to_extF80M( int32_t, extFloat80_t * );
+void i32_to_f128M( int32_t, float128_t * );
+float16_t i64_to_f16( int64_t );
+float32_t i64_to_f32( int64_t );
+float64_t i64_to_f64( int64_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t i64_to_extF80( int64_t );
+float128_t i64_to_f128( int64_t );
+#endif
+void i64_to_extF80M( int64_t, extFloat80_t * );
+void i64_to_f128M( int64_t, float128_t * );
+
+/*----------------------------------------------------------------------------
+| 16-bit (half-precision) floating-point operations.
+*----------------------------------------------------------------------------*/
+uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
+uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
+int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
+int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
+uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
+uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
+int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
+int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
+float32_t f16_to_f32( float16_t );
+float64_t f16_to_f64( float16_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f16_to_extF80( float16_t );
+float128_t f16_to_f128( float16_t );
+#endif
+void f16_to_extF80M( float16_t, extFloat80_t * );
+void f16_to_f128M( float16_t, float128_t * );
+float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
+float16_t f16_add( float16_t, float16_t );
+float16_t f16_sub( float16_t, float16_t );
+float16_t f16_mul( float16_t, float16_t );
+float16_t f16_mulAdd( float16_t, float16_t, float16_t );
+float16_t f16_div( float16_t, float16_t );
+float16_t f16_rem( float16_t, float16_t );
+float16_t f16_sqrt( float16_t );
+bool f16_eq( float16_t, float16_t );
+bool f16_le( float16_t, float16_t );
+bool f16_lt( float16_t, float16_t );
+bool f16_eq_signaling( float16_t, float16_t );
+bool f16_le_quiet( float16_t, float16_t );
+bool f16_lt_quiet( float16_t, float16_t );
+bool f16_isSignalingNaN( float16_t );
+
+/*----------------------------------------------------------------------------
+| 16-bit (brain float 16) floating-point operations.
+*----------------------------------------------------------------------------*/
+float32_t bf16_to_f32( bfloat16_t );
+bfloat16_t f32_to_bf16( float32_t );
+bool bf16_isSignalingNaN( bfloat16_t );
+
+/*----------------------------------------------------------------------------
+| 32-bit (single-precision) floating-point operations.
+*----------------------------------------------------------------------------*/
+uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
+uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
+int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
+int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );
+uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );
+uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );
+int_fast32_t f32_to_i32_r_minMag( float32_t, bool );
+int_fast64_t f32_to_i64_r_minMag( float32_t, bool );
+float16_t f32_to_f16( float32_t );
+float64_t f32_to_f64( float32_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f32_to_extF80( float32_t );
+float128_t f32_to_f128( float32_t );
+#endif
+void f32_to_extF80M( float32_t, extFloat80_t * );
+void f32_to_f128M( float32_t, float128_t * );
+float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );
+float32_t f32_add( float32_t, float32_t );
+float32_t f32_sub( float32_t, float32_t );
+float32_t f32_mul( float32_t, float32_t );
+float32_t f32_mulAdd( float32_t, float32_t, float32_t );
+float32_t f32_div( float32_t, float32_t );
+float32_t f32_rem( float32_t, float32_t );
+float32_t f32_sqrt( float32_t );
+bool f32_eq( float32_t, float32_t );
+bool f32_le( float32_t, float32_t );
+bool f32_lt( float32_t, float32_t );
+bool f32_eq_signaling( float32_t, float32_t );
+bool f32_le_quiet( float32_t, float32_t );
+bool f32_lt_quiet( float32_t, float32_t );
+bool f32_isSignalingNaN( float32_t );
+
+/*----------------------------------------------------------------------------
+| 64-bit (double-precision) floating-point operations.
+*----------------------------------------------------------------------------*/
+uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
+uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
+int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
+int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
+uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
+uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
+int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
+int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
+float16_t f64_to_f16( float64_t );
+float32_t f64_to_f32( float64_t );
+#ifdef SOFTFLOAT_FAST_INT64
+extFloat80_t f64_to_extF80( float64_t );
+float128_t f64_to_f128( float64_t );
+#endif
+void f64_to_extF80M( float64_t, extFloat80_t * );
+void f64_to_f128M( float64_t, float128_t * );
+float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
+float64_t f64_add( float64_t, float64_t );
+float64_t f64_sub( float64_t, float64_t );
+float64_t f64_mul( float64_t, float64_t );
+float64_t f64_mulAdd( float64_t, float64_t, float64_t );
+float64_t f64_div( float64_t, float64_t );
+float64_t f64_rem( float64_t, float64_t );
+float64_t f64_sqrt( float64_t );
+bool f64_eq( float64_t, float64_t );
+bool f64_le( float64_t, float64_t );
+bool f64_lt( float64_t, float64_t );
+bool f64_eq_signaling( float64_t, float64_t );
+bool f64_le_quiet( float64_t, float64_t );
+bool f64_lt_quiet( float64_t, float64_t );
+bool f64_isSignalingNaN( float64_t );
+
+/*----------------------------------------------------------------------------
+| Rounding precision for 80-bit extended double-precision floating-point.
+| Valid values are 32, 64, and 80.
+*----------------------------------------------------------------------------*/
+extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
+
+/*----------------------------------------------------------------------------
+| 80-bit extended double-precision floating-point operations.
+*----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_FAST_INT64
+uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
+uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
+int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
+int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
+uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
+uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
+int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
+int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
+float16_t extF80_to_f16( extFloat80_t );
+float32_t extF80_to_f32( extFloat80_t );
+float64_t extF80_to_f64( extFloat80_t );
+float128_t extF80_to_f128( extFloat80_t );
+extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
+extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
+extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
+extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
+extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
+extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
+extFloat80_t extF80_sqrt( extFloat80_t );
+bool extF80_eq( extFloat80_t, extFloat80_t );
+bool extF80_le( extFloat80_t, extFloat80_t );
+bool extF80_lt( extFloat80_t, extFloat80_t );
+bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
+bool extF80_le_quiet( extFloat80_t, extFloat80_t );
+bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
+bool extF80_isSignalingNaN( extFloat80_t );
+#endif
+uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
+uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
+int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
+int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
+uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
+uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
+int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
+int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
+float16_t extF80M_to_f16( const extFloat80_t * );
+float32_t extF80M_to_f32( const extFloat80_t * );
+float64_t extF80M_to_f64( const extFloat80_t * );
+void extF80M_to_f128M( const extFloat80_t *, float128_t * );
+void
+ extF80M_roundToInt(
+     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
+void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
+void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
+void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
+void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
+void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
+void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
+bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
+bool extF80M_isSignalingNaN( const extFloat80_t * );
+
+/*----------------------------------------------------------------------------
+| 128-bit (quadruple-precision) floating-point operations.
+*----------------------------------------------------------------------------*/
+#ifdef SOFTFLOAT_FAST_INT64
+uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
+uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
+int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
+int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
+uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
+uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
+int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
+int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
+float16_t f128_to_f16( float128_t );
+float32_t f128_to_f32( float128_t );
+float64_t f128_to_f64( float128_t );
+extFloat80_t f128_to_extF80( float128_t );
+float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
+float128_t f128_add( float128_t, float128_t );
+float128_t f128_sub( float128_t, float128_t );
+float128_t f128_mul( float128_t, float128_t );
+float128_t f128_mulAdd( float128_t, float128_t, float128_t );
+float128_t f128_div( float128_t, float128_t );
+float128_t f128_rem( float128_t, float128_t );
+float128_t f128_sqrt( float128_t );
+bool f128_eq( float128_t, float128_t );
+bool f128_le( float128_t, float128_t );
+bool f128_lt( float128_t, float128_t );
+bool f128_eq_signaling( float128_t, float128_t );
+bool f128_le_quiet( float128_t, float128_t );
+bool f128_lt_quiet( float128_t, float128_t );
+bool f128_isSignalingNaN( float128_t );
+#endif
+uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
+uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
+int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
+int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
+uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
+uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
+int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
+int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
+float16_t f128M_to_f16( const float128_t * );
+float32_t f128M_to_f32( const float128_t * );
+float64_t f128M_to_f64( const float128_t * );
+void f128M_to_extF80M( const float128_t *, extFloat80_t * );
+void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
+void f128M_add( const float128_t *, const float128_t *, float128_t * );
+void f128M_sub( const float128_t *, const float128_t *, float128_t * );
+void f128M_mul( const float128_t *, const float128_t *, float128_t * );
+void
+ f128M_mulAdd(
+     const float128_t *, const float128_t *, const float128_t *, float128_t *
+ );
+void f128M_div( const float128_t *, const float128_t *, float128_t * );
+void f128M_rem( const float128_t *, const float128_t *, float128_t * );
+void f128M_sqrt( const float128_t *, float128_t * );
+bool f128M_eq( const float128_t *, const float128_t * );
+bool f128M_le( const float128_t *, const float128_t * );
+bool f128M_lt( const float128_t *, const float128_t * );
+bool f128M_eq_signaling( const float128_t *, const float128_t * );
+bool f128M_le_quiet( const float128_t *, const float128_t * );
+bool f128M_lt_quiet( const float128_t *, const float128_t * );
+bool f128M_isSignalingNaN( const float128_t * );
+
+#endif
+
diff --git a/softfloat/source/include/softfloat_types.h b/softfloat/source/include/softfloat_types.h
index 3fcc9d5..25039b5 100644
--- a/softfloat/source/include/softfloat_types.h
+++ b/softfloat/source/include/softfloat_types.h
@@ -1,94 +1,82 @@
-
-/*============================================================================
-
-This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#ifndef softfloat_types_h
-#define softfloat_types_h 1
-
-#include <stdint.h>
-
-/*----------------------------------------------------------------------------
-| Types used to pass 16-bit, 32-bit, 64-bit, and 128-bit floating-point
-| arguments and results to/from functions.  These types must be exactly
-| 16 bits, 32 bits, 64 bits, and 128 bits in size, respectively.  Where a
-| platform has "native" support for IEEE-Standard floating-point formats,
-| the types below may, if desired, be defined as aliases for the native types
-| (typically 'float' and 'double', and possibly 'long double').
-*----------------------------------------------------------------------------*/
-typedef struct {
-    uint16_t v;
-} float16_t;
-typedef struct {
-    uint32_t v;
-} float32_t;
-typedef struct {
-    uint64_t v;
-} float64_t;
-typedef struct {
-    uint64_t v[2];
-} float128_t;
-
-/*----------------------------------------------------------------------------
-| The format of an 80-bit extended floating-point number in memory.  This
-| structure must contain a 16-bit field named 'signExp' and a 64-bit field
-| named 'signif'.
-*----------------------------------------------------------------------------*/
-#ifdef LITTLEENDIAN
-struct extFloat80M {
-    uint64_t signif;
-    uint16_t signExp;
-};
-#else
-struct extFloat80M {
-    uint16_t signExp;
-    uint64_t signif;
-};
-#endif
-
-/*----------------------------------------------------------------------------
-| The type used to pass 80-bit extended floating-point arguments and
-| results to/from functions.  This type must have size identical to
-| 'struct extFloat80M'.  Type 'extFloat80_t' can be defined as an alias for
-| 'struct extFloat80M'.  Alternatively, if a platform has "native" support
-| for IEEE-Standard 80-bit extended floating-point, it may be possible,
-| if desired, to define 'extFloat80_t' as an alias for the native type
-| (presumably either 'long double' or a nonstandard compiler-intrinsic type).
-| In that case, the 'signif' and 'signExp' fields of 'struct extFloat80M'
-| must align exactly with the locations in memory of the sign, exponent, and
-| significand of the native type.
-*----------------------------------------------------------------------------*/
-typedef struct extFloat80M extFloat80_t;
-
-#endif
+
+/*============================================================================
+
+This C header file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#ifndef softfloat_types_h
+#define softfloat_types_h 1
+
+#include <stdint.h>
+
+/*----------------------------------------------------------------------------
+| Types used to pass 16-bit, 32-bit, 64-bit, and 128-bit floating-point
+| arguments and results to/from functions.  These types must be exactly
+| 16 bits, 32 bits, 64 bits, and 128 bits in size, respectively.  Where a
+| platform has "native" support for IEEE-Standard floating-point formats,
+| the types below may, if desired, be defined as aliases for the native types
+| (typically 'float' and 'double', and possibly 'long double').
+*----------------------------------------------------------------------------*/
+typedef struct { uint16_t v; } float16_t;
+typedef struct { uint16_t v; } bfloat16_t;
+typedef struct { uint32_t v; } float32_t;
+typedef struct { uint64_t v; } float64_t;
+typedef struct { uint64_t v[2]; } float128_t;
+
+/*----------------------------------------------------------------------------
+| The format of an 80-bit extended floating-point number in memory.  This
+| structure must contain a 16-bit field named 'signExp' and a 64-bit field
+| named 'signif'.
+*----------------------------------------------------------------------------*/
+#ifdef LITTLEENDIAN
+struct extFloat80M { uint64_t signif; uint16_t signExp; };
+#else
+struct extFloat80M { uint16_t signExp; uint64_t signif; };
+#endif
+
+/*----------------------------------------------------------------------------
+| The type used to pass 80-bit extended floating-point arguments and
+| results to/from functions.  This type must have size identical to
+| 'struct extFloat80M'.  Type 'extFloat80_t' can be defined as an alias for
+| 'struct extFloat80M'.  Alternatively, if a platform has "native" support
+| for IEEE-Standard 80-bit extended floating-point, it may be possible,
+| if desired, to define 'extFloat80_t' as an alias for the native type
+| (presumably either 'long double' or a nonstandard compiler-intrinsic type).
+| In that case, the 'signif' and 'signExp' fields of 'struct extFloat80M'
+| must align exactly with the locations in memory of the sign, exponent, and
+| significand of the native type.
+*----------------------------------------------------------------------------*/
+typedef struct extFloat80M extFloat80_t;
+
+#endif
+
diff --git a/softfloat/source/s_add128.c b/softfloat/source/s_add128.c
index 5a9d508..9846643 100644
--- a/softfloat/source/s_add128.c
+++ b/softfloat/source/s_add128.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_add128
-
-struct uint128
- softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-    struct uint128 z;
-
-    z.v0 = a0 + b0;
-    z.v64 = a64 + b64 + (z.v0 < a0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_add128
+
+struct uint128
+ softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+    struct uint128 z;
+
+    z.v0 = a0 + b0;
+    z.v64 = a64 + b64 + (z.v0 < a0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_add256M.c b/softfloat/source/s_add256M.c
index 4fb46a1..bfecf7b 100644
--- a/softfloat/source/s_add256M.c
+++ b/softfloat/source/s_add256M.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_add256M
-
-void
- softfloat_add256M(
-     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )
-{
-    unsigned int index;
-    uint_fast8_t carry;
-    uint64_t wordA, wordZ;
-
-    index = indexWordLo( 4 );
-    carry = 0;
-    for (;;) {
-        wordA = aPtr[index];
-        wordZ = wordA + bPtr[index] + carry;
-        zPtr[index] = wordZ;
-        if ( index == indexWordHi( 4 ) ) break;
-        if ( wordZ != wordA ) carry = (wordZ < wordA);
-        index += wordIncr;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_add256M
+
+void
+ softfloat_add256M(
+     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )
+{
+    unsigned int index;
+    uint_fast8_t carry;
+    uint64_t wordA, wordZ;
+
+    index = indexWordLo( 4 );
+    carry = 0;
+    for (;;) {
+        wordA = aPtr[index];
+        wordZ = wordA + bPtr[index] + carry;
+        zPtr[index] = wordZ;
+        if ( index == indexWordHi( 4 ) ) break;
+        if ( wordZ != wordA ) carry = (wordZ < wordA);
+        index += wordIncr;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_addCarryM.c b/softfloat/source/s_addCarryM.c
index f0ccf67..fb84a38 100644
--- a/softfloat/source/s_addCarryM.c
+++ b/softfloat/source/s_addCarryM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_addCarryM
-
-uint_fast8_t
- softfloat_addCarryM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint_fast8_t carry,
-     uint32_t *zPtr
- )
-{
-    unsigned int index, lastIndex;
-    uint32_t wordA, wordZ;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    for (;;) {
-        wordA = aPtr[index];
-        wordZ = wordA + bPtr[index] + carry;
-        zPtr[index] = wordZ;
-        if ( wordZ != wordA ) carry = (wordZ < wordA);
-        if ( index == lastIndex ) break;
-        index += wordIncr;
-    }
-    return carry;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_addCarryM
+
+uint_fast8_t
+ softfloat_addCarryM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint_fast8_t carry,
+     uint32_t *zPtr
+ )
+{
+    unsigned int index, lastIndex;
+    uint32_t wordA, wordZ;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    for (;;) {
+        wordA = aPtr[index];
+        wordZ = wordA + bPtr[index] + carry;
+        zPtr[index] = wordZ;
+        if ( wordZ != wordA ) carry = (wordZ < wordA);
+        if ( index == lastIndex ) break;
+        index += wordIncr;
+    }
+    return carry;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_addComplCarryM.c b/softfloat/source/s_addComplCarryM.c
index e1584c6..1f8d543 100644
--- a/softfloat/source/s_addComplCarryM.c
+++ b/softfloat/source/s_addComplCarryM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_addComplCarryM
-
-uint_fast8_t
- softfloat_addComplCarryM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint_fast8_t carry,
-     uint32_t *zPtr
- )
-{
-    unsigned int index, lastIndex;
-    uint32_t wordA, wordZ;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    for (;;) {
-        wordA = aPtr[index];
-        wordZ = wordA + ~bPtr[index] + carry;
-        zPtr[index] = wordZ;
-        if ( wordZ != wordA ) carry = (wordZ < wordA);
-        if ( index == lastIndex ) break;
-        index += wordIncr;
-    }
-    return carry;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_addComplCarryM
+
+uint_fast8_t
+ softfloat_addComplCarryM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint_fast8_t carry,
+     uint32_t *zPtr
+ )
+{
+    unsigned int index, lastIndex;
+    uint32_t wordA, wordZ;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    for (;;) {
+        wordA = aPtr[index];
+        wordZ = wordA + ~bPtr[index] + carry;
+        zPtr[index] = wordZ;
+        if ( wordZ != wordA ) carry = (wordZ < wordA);
+        if ( index == lastIndex ) break;
+        index += wordIncr;
+    }
+    return carry;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_addExtF80M.c b/softfloat/source/s_addExtF80M.c
index febfb65..f014290 100644
--- a/softfloat/source/s_addExtF80M.c
+++ b/softfloat/source/s_addExtF80M.c
@@ -1,186 +1,186 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-void
- softfloat_addExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr,
-     bool negateB
- )
-{
-    uint32_t uiA64;
-    int32_t expA;
-    uint32_t uiB64;
-    int32_t expB;
-    uint32_t uiZ64;
-    bool signZ, signB;
-    const struct extFloat80M *tempSPtr;
-    uint64_t sigZ, sigB;
-    void
-     (*roundPackRoutinePtr)(
-         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
-    int32_t expDiff;
-    uint32_t extSigX[3], sigZExtra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    expA = expExtF80UI64( uiA64 );
-    uiB64 = bSPtr->signExp;
-    expB = expExtF80UI64( uiB64 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
-        uiZ64 = uiA64;
-        if ( expB == 0x7FFF ) {
-            uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 );
-            if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) {
-                softfloat_invalidExtF80M( zSPtr );
-                return;
-            }
-        }
-        zSPtr->signExp = uiZ64;
-        zSPtr->signif = UINT64_C( 0x8000000000000000 );
-        return;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signZ = signExtF80UI64( uiA64 );
-    signB = signExtF80UI64( uiB64 ) ^ negateB;
-    negateB = (signZ != signB);
-    if ( expA < expB ) {
-        signZ = signB;
-        expA = expB;
-        expB = expExtF80UI64( uiA64 );
-        tempSPtr = aSPtr;
-        aSPtr = bSPtr;
-        bSPtr = tempSPtr;
-    }
-    if ( ! expB ) {
-        expB = 1;
-        if ( ! expA ) expA = 1;
-    }
-    sigZ = aSPtr->signif;
-    sigB = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundPackRoutinePtr = softfloat_roundPackMToExtF80M;
-    expDiff = expA - expB;
-    if ( expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        extSigX[indexWord( 3, 2 )] = sigB>>32;
-        extSigX[indexWord( 3, 1 )] = sigB;
-        extSigX[indexWord( 3, 0 )] = 0;
-        softfloat_shiftRightJam96M( extSigX, expDiff, extSigX );
-        sigB =
-            (uint64_t) extSigX[indexWord( 3, 2 )]<<32
-                | extSigX[indexWord( 3, 1 )];
-        if ( negateB ) {
-            sigZ -= sigB;
-            sigZExtra = extSigX[indexWordLo( 3 )];
-            if ( sigZExtra ) {
-                --sigZ;
-                sigZExtra = -sigZExtra;
-            }
-            if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) {
-                if ( sigZ & UINT64_C( 0x4000000000000000 ) ) {
-                    --expA;
-                    sigZ = sigZ<<1 | sigZExtra>>31;
-                    sigZExtra <<= 1;
-                } else {
-                    roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
-                }
-            }
-        } else {
-            sigZ += sigB;
-            if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto sigZ;
-            sigZExtra = (uint32_t) sigZ<<31 | (extSigX[indexWordLo( 3 )] != 0);
-            goto completeNormAfterAdd;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sigZExtra = 0;
-        if ( negateB ) {
-            if ( sigZ < sigB ) {
-                signZ = ! signZ;
-                sigZ = sigB - sigZ;
-            } else {
-                sigZ -= sigB;
-                if ( ! sigZ ) {
-                    signZ = (softfloat_roundingMode == softfloat_round_min);
-                    zSPtr->signExp = packToExtF80UI64( signZ, 0 );
-                    zSPtr->signif = 0;
-                    return;
-                }
-            }
-            roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
-        } else {
-            sigZ += sigB;
-            if ( sigZ < sigB ) {
-                sigZExtra = (uint32_t) sigZ<<31;
- completeNormAfterAdd:
-                ++expA;
-                sigZ = UINT64_C( 0x8000000000000000 ) | sigZ>>1;
-            } else {
-                if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) {
-                    roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
-                }
-            }
-        }
-    }
-    extSigX[indexWord( 3, 0 )] = sigZExtra;
- sigZ:
-    extSigX[indexWord( 3, 2 )] = sigZ>>32;
-    extSigX[indexWord( 3, 1 )] = sigZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- roundPack:
-    (*roundPackRoutinePtr)(
-        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void
+ softfloat_addExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr,
+     bool negateB
+ )
+{
+    uint32_t uiA64;
+    int32_t expA;
+    uint32_t uiB64;
+    int32_t expB;
+    uint32_t uiZ64;
+    bool signZ, signB;
+    const struct extFloat80M *tempSPtr;
+    uint64_t sigZ, sigB;
+    void
+     (*roundPackRoutinePtr)(
+         bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+    int32_t expDiff;
+    uint32_t extSigX[3], sigZExtra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    expA = expExtF80UI64( uiA64 );
+    uiB64 = bSPtr->signExp;
+    expB = expExtF80UI64( uiB64 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNExtF80M( aSPtr, bSPtr, zSPtr ) ) return;
+        uiZ64 = uiA64;
+        if ( expB == 0x7FFF ) {
+            uiZ64 = uiB64 ^ packToExtF80UI64( negateB, 0 );
+            if ( (expA == 0x7FFF) && (uiZ64 != uiA64) ) {
+                softfloat_invalidExtF80M( zSPtr );
+                return;
+            }
+        }
+        zSPtr->signExp = uiZ64;
+        zSPtr->signif = UINT64_C( 0x8000000000000000 );
+        return;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signZ = signExtF80UI64( uiA64 );
+    signB = signExtF80UI64( uiB64 ) ^ negateB;
+    negateB = (signZ != signB);
+    if ( expA < expB ) {
+        signZ = signB;
+        expA = expB;
+        expB = expExtF80UI64( uiA64 );
+        tempSPtr = aSPtr;
+        aSPtr = bSPtr;
+        bSPtr = tempSPtr;
+    }
+    if ( ! expB ) {
+        expB = 1;
+        if ( ! expA ) expA = 1;
+    }
+    sigZ = aSPtr->signif;
+    sigB = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundPackRoutinePtr = softfloat_roundPackMToExtF80M;
+    expDiff = expA - expB;
+    if ( expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        extSigX[indexWord( 3, 2 )] = sigB>>32;
+        extSigX[indexWord( 3, 1 )] = sigB;
+        extSigX[indexWord( 3, 0 )] = 0;
+        softfloat_shiftRightJam96M( extSigX, expDiff, extSigX );
+        sigB =
+            (uint64_t) extSigX[indexWord( 3, 2 )]<<32
+                | extSigX[indexWord( 3, 1 )];
+        if ( negateB ) {
+            sigZ -= sigB;
+            sigZExtra = extSigX[indexWordLo( 3 )];
+            if ( sigZExtra ) {
+                --sigZ;
+                sigZExtra = -sigZExtra;
+            }
+            if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) {
+                if ( sigZ & UINT64_C( 0x4000000000000000 ) ) {
+                    --expA;
+                    sigZ = sigZ<<1 | sigZExtra>>31;
+                    sigZExtra <<= 1;
+                } else {
+                    roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
+                }
+            }
+        } else {
+            sigZ += sigB;
+            if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto sigZ;
+            sigZExtra = (uint32_t) sigZ<<31 | (extSigX[indexWordLo( 3 )] != 0);
+            goto completeNormAfterAdd;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sigZExtra = 0;
+        if ( negateB ) {
+            if ( sigZ < sigB ) {
+                signZ = ! signZ;
+                sigZ = sigB - sigZ;
+            } else {
+                sigZ -= sigB;
+                if ( ! sigZ ) {
+                    signZ = (softfloat_roundingMode == softfloat_round_min);
+                    zSPtr->signExp = packToExtF80UI64( signZ, 0 );
+                    zSPtr->signif = 0;
+                    return;
+                }
+            }
+            roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
+        } else {
+            sigZ += sigB;
+            if ( sigZ < sigB ) {
+                sigZExtra = (uint32_t) sigZ<<31;
+ completeNormAfterAdd:
+                ++expA;
+                sigZ = UINT64_C( 0x8000000000000000 ) | sigZ>>1;
+            } else {
+                if ( ! (sigZ & UINT64_C( 0x8000000000000000 )) ) {
+                    roundPackRoutinePtr = softfloat_normRoundPackMToExtF80M;
+                }
+            }
+        }
+    }
+    extSigX[indexWord( 3, 0 )] = sigZExtra;
+ sigZ:
+    extSigX[indexWord( 3, 2 )] = sigZ>>32;
+    extSigX[indexWord( 3, 1 )] = sigZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ roundPack:
+    (*roundPackRoutinePtr)(
+        signZ, expA, extSigX, extF80_roundingPrecision, zSPtr );
+
+}
+
diff --git a/softfloat/source/s_addF128M.c b/softfloat/source/s_addF128M.c
index 8ed9d27..c5fcf70 100644
--- a/softfloat/source/s_addF128M.c
+++ b/softfloat/source/s_addF128M.c
@@ -1,211 +1,211 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-void
- softfloat_addF128M(
-     const uint32_t *aWPtr,
-     const uint32_t *bWPtr,
-     uint32_t *zWPtr,
-     bool negateB
- )
-{
-    uint32_t uiA96;
-    int32_t expA;
-    uint32_t uiB96;
-    int32_t expB;
-    uint32_t uiZ96;
-    bool signZ, signB;
-    const uint32_t *tempPtr;
-    uint32_t sig96A, sig96B;
-    int32_t expDiff;
-    uint_fast8_t
-     (*addCarryMRoutinePtr)(
-         uint_fast8_t,
-         const uint32_t *,
-         const uint32_t *,
-         uint_fast8_t,
-         uint32_t *
-     );
-    uint32_t extSigZ[5], wordSigZ;
-    uint_fast8_t carry;
-    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    expA = expF128UI96( uiA96 );
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    expB = expF128UI96( uiB96 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
-        uiZ96 = uiA96;
-        if ( expB == 0x7FFF ) {
-            uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
-            if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
-                softfloat_invalidF128M( zWPtr );
-                return;
-            }
-        }
-        zWPtr[indexWordHi( 4 )] = uiZ96;
-        zWPtr[indexWord( 4, 2 )] = 0;
-        zWPtr[indexWord( 4, 1 )] = 0;
-        zWPtr[indexWord( 4, 0 )] = 0;
-        return;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signZ = signF128UI96( uiA96 );
-    signB = signF128UI96( uiB96 ) ^ negateB;
-    negateB = (signZ != signB);
-    if ( (uint32_t) (uiA96<<1) < (uint32_t) (uiB96<<1) ) {
-        signZ = signB;
-        expA = expB;
-        expB = expF128UI96( uiA96 );
-        tempPtr = aWPtr;
-        aWPtr = bWPtr;
-        bWPtr = tempPtr;
-        uiA96 = uiB96;
-        uiB96 = bWPtr[indexWordHi( 4 )];
-    }
-    sig96A = fracF128UI96( uiA96 );
-    sig96B = fracF128UI96( uiB96 );
-    if ( expA ) {
-        --expA;
-        sig96A |= 0x00010000;
-        if ( expB ) {
-            --expB;
-            sig96B |= 0x00010000;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    addCarryMRoutinePtr =
-        negateB ? softfloat_addComplCarryM : softfloat_addCarryM;
-    expDiff = expA - expB;
-    if ( expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        extSigZ[indexWordHi( 5 )] = sig96B;
-        extSigZ[indexWord( 5, 3 )] = bWPtr[indexWord( 4, 2 )];
-        extSigZ[indexWord( 5, 2 )] = bWPtr[indexWord( 4, 1 )];
-        extSigZ[indexWord( 5, 1 )] = bWPtr[indexWord( 4, 0 )];
-        extSigZ[indexWord( 5, 0 )] = 0;
-        softfloat_shiftRightJam160M( extSigZ, expDiff, extSigZ );
-        sig96B = extSigZ[indexWordHi( 5 )];
-        carry = 0;
-        if ( negateB ) {
-            sig96B = ~sig96B;
-            wordSigZ = extSigZ[indexWordLo( 5 )];
-            extSigZ[indexWordLo( 5 )] = -wordSigZ;
-            carry = ! wordSigZ;
-        }
-        carry =
-            (*addCarryMRoutinePtr)(
-                3,
-                &aWPtr[indexMultiwordLo( 4, 3 )],
-                &extSigZ[indexMultiword( 5, 3, 1 )],
-                carry,
-                &extSigZ[indexMultiword( 5, 3, 1 )]
-            );
-        wordSigZ = sig96A + sig96B + carry;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        extSigZ[indexWordLo( 5 )] = 0;
-        carry =
-            (*addCarryMRoutinePtr)(
-                3,
-                &aWPtr[indexMultiwordLo( 4, 3 )],
-                &bWPtr[indexMultiwordLo( 4, 3 )],
-                negateB,
-                &extSigZ[indexMultiword( 5, 3, 1 )]
-            );
-        if ( negateB ) {
-            wordSigZ = sig96A + ~sig96B + carry;
-            if ( wordSigZ & 0x80000000 ) {
-                signZ = ! signZ;
-                carry =
-                    softfloat_addComplCarry96M(
-                        &bWPtr[indexMultiwordLo( 4, 3 )],
-                        &aWPtr[indexMultiwordLo( 4, 3 )],
-                        1,
-                        &extSigZ[indexMultiword( 5, 3, 1 )]
-                    );
-                wordSigZ = sig96B + ~sig96A + carry;
-            } else {
-                if (
-                    ! wordSigZ && ! extSigZ[indexWord( 5, 3 )]
-                        && ! (  extSigZ[indexWord( 5, 2 )]
-                              | extSigZ[indexWord( 5, 1 )]
-                              | extSigZ[indexWord( 5, 0 )]
-                             )
-                ) {
-                    signZ = (softfloat_roundingMode == softfloat_round_min);
-                    zWPtr[indexWordHi( 4 )] = packToF128UI96( signZ, 0, 0 );
-                    zWPtr[indexWord( 4, 2 )] = 0;
-                    zWPtr[indexWord( 4, 1 )] = 0;
-                    zWPtr[indexWord( 4, 0 )] = 0;
-                    return;
-                }
-            }
-        } else {
-            wordSigZ = sig96A + sig96B + carry;
-        }
-    }
-    extSigZ[indexWordHi( 5 )] = wordSigZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundPackRoutinePtr = softfloat_normRoundPackMToF128M;
-    if ( 0x00010000 <= wordSigZ ) {
-        if ( 0x00020000 <= wordSigZ ) {
-            ++expA;
-            softfloat_shortShiftRightJam160M( extSigZ, 1, extSigZ );
-        }
-        roundPackRoutinePtr = softfloat_roundPackMToF128M;
-    }
-    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void
+ softfloat_addF128M(
+     const uint32_t *aWPtr,
+     const uint32_t *bWPtr,
+     uint32_t *zWPtr,
+     bool negateB
+ )
+{
+    uint32_t uiA96;
+    int32_t expA;
+    uint32_t uiB96;
+    int32_t expB;
+    uint32_t uiZ96;
+    bool signZ, signB;
+    const uint32_t *tempPtr;
+    uint32_t sig96A, sig96B;
+    int32_t expDiff;
+    uint_fast8_t
+     (*addCarryMRoutinePtr)(
+         uint_fast8_t,
+         const uint32_t *,
+         const uint32_t *,
+         uint_fast8_t,
+         uint32_t *
+     );
+    uint32_t extSigZ[5], wordSigZ;
+    uint_fast8_t carry;
+    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    expA = expF128UI96( uiA96 );
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    expB = expF128UI96( uiB96 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) return;
+        uiZ96 = uiA96;
+        if ( expB == 0x7FFF ) {
+            uiZ96 = uiB96 ^ packToF128UI96( negateB, 0, 0 );
+            if ( (expA == 0x7FFF) && (uiZ96 != uiA96) ) {
+                softfloat_invalidF128M( zWPtr );
+                return;
+            }
+        }
+        zWPtr[indexWordHi( 4 )] = uiZ96;
+        zWPtr[indexWord( 4, 2 )] = 0;
+        zWPtr[indexWord( 4, 1 )] = 0;
+        zWPtr[indexWord( 4, 0 )] = 0;
+        return;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signZ = signF128UI96( uiA96 );
+    signB = signF128UI96( uiB96 ) ^ negateB;
+    negateB = (signZ != signB);
+    if ( (uint32_t) (uiA96<<1) < (uint32_t) (uiB96<<1) ) {
+        signZ = signB;
+        expA = expB;
+        expB = expF128UI96( uiA96 );
+        tempPtr = aWPtr;
+        aWPtr = bWPtr;
+        bWPtr = tempPtr;
+        uiA96 = uiB96;
+        uiB96 = bWPtr[indexWordHi( 4 )];
+    }
+    sig96A = fracF128UI96( uiA96 );
+    sig96B = fracF128UI96( uiB96 );
+    if ( expA ) {
+        --expA;
+        sig96A |= 0x00010000;
+        if ( expB ) {
+            --expB;
+            sig96B |= 0x00010000;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    addCarryMRoutinePtr =
+        negateB ? softfloat_addComplCarryM : softfloat_addCarryM;
+    expDiff = expA - expB;
+    if ( expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        extSigZ[indexWordHi( 5 )] = sig96B;
+        extSigZ[indexWord( 5, 3 )] = bWPtr[indexWord( 4, 2 )];
+        extSigZ[indexWord( 5, 2 )] = bWPtr[indexWord( 4, 1 )];
+        extSigZ[indexWord( 5, 1 )] = bWPtr[indexWord( 4, 0 )];
+        extSigZ[indexWord( 5, 0 )] = 0;
+        softfloat_shiftRightJam160M( extSigZ, expDiff, extSigZ );
+        sig96B = extSigZ[indexWordHi( 5 )];
+        carry = 0;
+        if ( negateB ) {
+            sig96B = ~sig96B;
+            wordSigZ = extSigZ[indexWordLo( 5 )];
+            extSigZ[indexWordLo( 5 )] = -wordSigZ;
+            carry = ! wordSigZ;
+        }
+        carry =
+            (*addCarryMRoutinePtr)(
+                3,
+                &aWPtr[indexMultiwordLo( 4, 3 )],
+                &extSigZ[indexMultiword( 5, 3, 1 )],
+                carry,
+                &extSigZ[indexMultiword( 5, 3, 1 )]
+            );
+        wordSigZ = sig96A + sig96B + carry;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        extSigZ[indexWordLo( 5 )] = 0;
+        carry =
+            (*addCarryMRoutinePtr)(
+                3,
+                &aWPtr[indexMultiwordLo( 4, 3 )],
+                &bWPtr[indexMultiwordLo( 4, 3 )],
+                negateB,
+                &extSigZ[indexMultiword( 5, 3, 1 )]
+            );
+        if ( negateB ) {
+            wordSigZ = sig96A + ~sig96B + carry;
+            if ( wordSigZ & 0x80000000 ) {
+                signZ = ! signZ;
+                carry =
+                    softfloat_addComplCarry96M(
+                        &bWPtr[indexMultiwordLo( 4, 3 )],
+                        &aWPtr[indexMultiwordLo( 4, 3 )],
+                        1,
+                        &extSigZ[indexMultiword( 5, 3, 1 )]
+                    );
+                wordSigZ = sig96B + ~sig96A + carry;
+            } else {
+                if (
+                    ! wordSigZ && ! extSigZ[indexWord( 5, 3 )]
+                        && ! (  extSigZ[indexWord( 5, 2 )]
+                              | extSigZ[indexWord( 5, 1 )]
+                              | extSigZ[indexWord( 5, 0 )]
+                             )
+                ) {
+                    signZ = (softfloat_roundingMode == softfloat_round_min);
+                    zWPtr[indexWordHi( 4 )] = packToF128UI96( signZ, 0, 0 );
+                    zWPtr[indexWord( 4, 2 )] = 0;
+                    zWPtr[indexWord( 4, 1 )] = 0;
+                    zWPtr[indexWord( 4, 0 )] = 0;
+                    return;
+                }
+            }
+        } else {
+            wordSigZ = sig96A + sig96B + carry;
+        }
+    }
+    extSigZ[indexWordHi( 5 )] = wordSigZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundPackRoutinePtr = softfloat_normRoundPackMToF128M;
+    if ( 0x00010000 <= wordSigZ ) {
+        if ( 0x00020000 <= wordSigZ ) {
+            ++expA;
+            softfloat_shortShiftRightJam160M( extSigZ, 1, extSigZ );
+        }
+        roundPackRoutinePtr = softfloat_roundPackMToF128M;
+    }
+    (*roundPackRoutinePtr)( signZ, expA, extSigZ, zWPtr );
+
+}
+
diff --git a/softfloat/source/s_addM.c b/softfloat/source/s_addM.c
index c935baa..e1cc66b 100644
--- a/softfloat/source/s_addM.c
+++ b/softfloat/source/s_addM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_addM
-
-void
- softfloat_addM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint32_t *zPtr
- )
-{
-    unsigned int index, lastIndex;
-    uint_fast8_t carry;
-    uint32_t wordA, wordZ;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    carry = 0;
-    for (;;) {
-        wordA = aPtr[index];
-        wordZ = wordA + bPtr[index] + carry;
-        zPtr[index] = wordZ;
-        if ( index == lastIndex ) break;
-        if ( wordZ != wordA ) carry = (wordZ < wordA);
-        index += wordIncr;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_addM
+
+void
+ softfloat_addM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint32_t *zPtr
+ )
+{
+    unsigned int index, lastIndex;
+    uint_fast8_t carry;
+    uint32_t wordA, wordZ;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    carry = 0;
+    for (;;) {
+        wordA = aPtr[index];
+        wordZ = wordA + bPtr[index] + carry;
+        zPtr[index] = wordZ;
+        if ( index == lastIndex ) break;
+        if ( wordZ != wordA ) carry = (wordZ < wordA);
+        index += wordIncr;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_addMagsExtF80.c b/softfloat/source/s_addMagsExtF80.c
index b1bb5db..6e7d1a6 100644
--- a/softfloat/source/s_addMagsExtF80.c
+++ b/softfloat/source/s_addMagsExtF80.c
@@ -1,156 +1,156 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t
- softfloat_addMagsExtF80(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0,
-     bool signZ
- )
-{
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    int_fast32_t expB;
-    uint_fast64_t sigB;
-    int_fast32_t expDiff;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0, sigZ, sigZExtra;
-    struct exp32_sig64 normExpSig;
-    int_fast32_t expZ;
-    struct uint64_extra sig64Extra;
-    struct uint128 uiZ;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expExtF80UI64( uiA64 );
-    sigA = uiA0;
-    expB = expExtF80UI64( uiB64 );
-    sigB = uiB0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        if ( expA == 0x7FFF ) {
-            if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-                goto propagateNaN;
-            }
-            uiZ64 = uiA64;
-            uiZ0  = uiA0;
-            goto uiZ;
-        }
-        sigZ = sigA + sigB;
-        sigZExtra = 0;
-        if ( ! expA ) {
-            normExpSig = softfloat_normSubnormalExtF80Sig( sigZ );
-            expZ = normExpSig.exp + 1;
-            sigZ = normExpSig.sig;
-            goto roundAndPack;
-        }
-        expZ = expA;
-        goto shiftRight1;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expDiff < 0 ) {
-        if ( expB == 0x7FFF ) {
-            if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-            uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
-            uiZ0  = uiB0;
-            goto uiZ;
-        }
-        expZ = expB;
-        if ( ! expA ) {
-            ++expDiff;
-            sigZExtra = 0;
-            if ( ! expDiff ) goto newlyAligned;
-        }
-        sig64Extra = softfloat_shiftRightJam64Extra( sigA, 0, -expDiff );
-        sigA = sig64Extra.v;
-        sigZExtra = sig64Extra.extra;
-    } else {
-        if ( expA == 0x7FFF ) {
-            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-            uiZ64 = uiA64;
-            uiZ0  = uiA0;
-            goto uiZ;
-        }
-        expZ = expA;
-        if ( ! expB ) {
-            --expDiff;
-            sigZExtra = 0;
-            if ( ! expDiff ) goto newlyAligned;
-        }
-        sig64Extra = softfloat_shiftRightJam64Extra( sigB, 0, expDiff );
-        sigB = sig64Extra.v;
-        sigZExtra = sig64Extra.extra;
-    }
- newlyAligned:
-    sigZ = sigA + sigB;
-    if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto roundAndPack;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- shiftRight1:
-    sig64Extra = softfloat_shortShiftRightJam64Extra( sigZ, sigZExtra, 1 );
-    sigZ = sig64Extra.v | UINT64_C( 0x8000000000000000 );
-    sigZExtra = sig64Extra.extra;
-    ++expZ;
- roundAndPack:
-    return
-        softfloat_roundPackToExtF80(
-            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
-    uiZ64 = uiZ.v64;
-    uiZ0  = uiZ.v0;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t
+ softfloat_addMagsExtF80(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0,
+     bool signZ
+ )
+{
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    int_fast32_t expB;
+    uint_fast64_t sigB;
+    int_fast32_t expDiff;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0, sigZ, sigZExtra;
+    struct exp32_sig64 normExpSig;
+    int_fast32_t expZ;
+    struct uint64_extra sig64Extra;
+    struct uint128 uiZ;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expExtF80UI64( uiA64 );
+    sigA = uiA0;
+    expB = expExtF80UI64( uiB64 );
+    sigB = uiB0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        if ( expA == 0x7FFF ) {
+            if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+                goto propagateNaN;
+            }
+            uiZ64 = uiA64;
+            uiZ0  = uiA0;
+            goto uiZ;
+        }
+        sigZ = sigA + sigB;
+        sigZExtra = 0;
+        if ( ! expA ) {
+            normExpSig = softfloat_normSubnormalExtF80Sig( sigZ );
+            expZ = normExpSig.exp + 1;
+            sigZ = normExpSig.sig;
+            goto roundAndPack;
+        }
+        expZ = expA;
+        goto shiftRight1;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expDiff < 0 ) {
+        if ( expB == 0x7FFF ) {
+            if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+            uiZ64 = packToExtF80UI64( signZ, 0x7FFF );
+            uiZ0  = uiB0;
+            goto uiZ;
+        }
+        expZ = expB;
+        if ( ! expA ) {
+            ++expDiff;
+            sigZExtra = 0;
+            if ( ! expDiff ) goto newlyAligned;
+        }
+        sig64Extra = softfloat_shiftRightJam64Extra( sigA, 0, -expDiff );
+        sigA = sig64Extra.v;
+        sigZExtra = sig64Extra.extra;
+    } else {
+        if ( expA == 0x7FFF ) {
+            if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+            uiZ64 = uiA64;
+            uiZ0  = uiA0;
+            goto uiZ;
+        }
+        expZ = expA;
+        if ( ! expB ) {
+            --expDiff;
+            sigZExtra = 0;
+            if ( ! expDiff ) goto newlyAligned;
+        }
+        sig64Extra = softfloat_shiftRightJam64Extra( sigB, 0, expDiff );
+        sigB = sig64Extra.v;
+        sigZExtra = sig64Extra.extra;
+    }
+ newlyAligned:
+    sigZ = sigA + sigB;
+    if ( sigZ & UINT64_C( 0x8000000000000000 ) ) goto roundAndPack;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ shiftRight1:
+    sig64Extra = softfloat_shortShiftRightJam64Extra( sigZ, sigZExtra, 1 );
+    sigZ = sig64Extra.v | UINT64_C( 0x8000000000000000 );
+    sigZExtra = sig64Extra.extra;
+    ++expZ;
+ roundAndPack:
+    return
+        softfloat_roundPackToExtF80(
+            signZ, expZ, sigZ, sigZExtra, extF80_roundingPrecision );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ64 = uiZ.v64;
+    uiZ0  = uiZ.v0;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_addMagsF128.c b/softfloat/source/s_addMagsF128.c
index 8e5ce5b..da8e888 100644
--- a/softfloat/source/s_addMagsF128.c
+++ b/softfloat/source/s_addMagsF128.c
@@ -1,154 +1,154 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-float128_t
- softfloat_addMagsF128(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0,
-     bool signZ
- )
-{
-    int_fast32_t expA;
-    struct uint128 sigA;
-    int_fast32_t expB;
-    struct uint128 sigB;
-    int_fast32_t expDiff;
-    struct uint128 uiZ, sigZ;
-    int_fast32_t expZ;
-    uint_fast64_t sigZExtra;
-    struct uint128_extra sig128Extra;
-    union ui128_f128 uZ;
-
-    expA = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    expB = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        if ( expA == 0x7FFF ) {
-            if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
-            uiZ.v64 = uiA64;
-            uiZ.v0  = uiA0;
-            goto uiZ;
-        }
-        sigZ = softfloat_add128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
-        if ( ! expA ) {
-            uiZ.v64 = packToF128UI64( signZ, 0, sigZ.v64 );
-            uiZ.v0  = sigZ.v0;
-            goto uiZ;
-        }
-        expZ = expA;
-        sigZ.v64 |= UINT64_C( 0x0002000000000000 );
-        sigZExtra = 0;
-        goto shiftRight1;
-    }
-    if ( expDiff < 0 ) {
-        if ( expB == 0x7FFF ) {
-            if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-            uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
-            uiZ.v0  = 0;
-            goto uiZ;
-        }
-        expZ = expB;
-        if ( expA ) {
-            sigA.v64 |= UINT64_C( 0x0001000000000000 );
-        } else {
-            ++expDiff;
-            sigZExtra = 0;
-            if ( ! expDiff ) goto newlyAligned;
-        }
-        sig128Extra =
-            softfloat_shiftRightJam128Extra( sigA.v64, sigA.v0, 0, -expDiff );
-        sigA = sig128Extra.v;
-        sigZExtra = sig128Extra.extra;
-    } else {
-        if ( expA == 0x7FFF ) {
-            if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
-            uiZ.v64 = uiA64;
-            uiZ.v0  = uiA0;
-            goto uiZ;
-        }
-        expZ = expA;
-        if ( expB ) {
-            sigB.v64 |= UINT64_C( 0x0001000000000000 );
-        } else {
-            --expDiff;
-            sigZExtra = 0;
-            if ( ! expDiff ) goto newlyAligned;
-        }
-        sig128Extra =
-            softfloat_shiftRightJam128Extra( sigB.v64, sigB.v0, 0, expDiff );
-        sigB = sig128Extra.v;
-        sigZExtra = sig128Extra.extra;
-    }
- newlyAligned:
-    sigZ =
-        softfloat_add128(
-            sigA.v64 | UINT64_C( 0x0001000000000000 ),
-            sigA.v0,
-            sigB.v64,
-            sigB.v0
-        );
-    --expZ;
-    if ( sigZ.v64 < UINT64_C( 0x0002000000000000 ) ) goto roundAndPack;
-    ++expZ;
- shiftRight1:
-    sig128Extra =
-        softfloat_shortShiftRightJam128Extra(
-            sigZ.v64, sigZ.v0, sigZExtra, 1 );
-    sigZ = sig128Extra.v;
-    sigZExtra = sig128Extra.extra;
- roundAndPack:
-    return
-        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+float128_t
+ softfloat_addMagsF128(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0,
+     bool signZ
+ )
+{
+    int_fast32_t expA;
+    struct uint128 sigA;
+    int_fast32_t expB;
+    struct uint128 sigB;
+    int_fast32_t expDiff;
+    struct uint128 uiZ, sigZ;
+    int_fast32_t expZ;
+    uint_fast64_t sigZExtra;
+    struct uint128_extra sig128Extra;
+    union ui128_f128 uZ;
+
+    expA = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    expB = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        if ( expA == 0x7FFF ) {
+            if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
+            uiZ.v64 = uiA64;
+            uiZ.v0  = uiA0;
+            goto uiZ;
+        }
+        sigZ = softfloat_add128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
+        if ( ! expA ) {
+            uiZ.v64 = packToF128UI64( signZ, 0, sigZ.v64 );
+            uiZ.v0  = sigZ.v0;
+            goto uiZ;
+        }
+        expZ = expA;
+        sigZ.v64 |= UINT64_C( 0x0002000000000000 );
+        sigZExtra = 0;
+        goto shiftRight1;
+    }
+    if ( expDiff < 0 ) {
+        if ( expB == 0x7FFF ) {
+            if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+            uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
+            uiZ.v0  = 0;
+            goto uiZ;
+        }
+        expZ = expB;
+        if ( expA ) {
+            sigA.v64 |= UINT64_C( 0x0001000000000000 );
+        } else {
+            ++expDiff;
+            sigZExtra = 0;
+            if ( ! expDiff ) goto newlyAligned;
+        }
+        sig128Extra =
+            softfloat_shiftRightJam128Extra( sigA.v64, sigA.v0, 0, -expDiff );
+        sigA = sig128Extra.v;
+        sigZExtra = sig128Extra.extra;
+    } else {
+        if ( expA == 0x7FFF ) {
+            if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
+            uiZ.v64 = uiA64;
+            uiZ.v0  = uiA0;
+            goto uiZ;
+        }
+        expZ = expA;
+        if ( expB ) {
+            sigB.v64 |= UINT64_C( 0x0001000000000000 );
+        } else {
+            --expDiff;
+            sigZExtra = 0;
+            if ( ! expDiff ) goto newlyAligned;
+        }
+        sig128Extra =
+            softfloat_shiftRightJam128Extra( sigB.v64, sigB.v0, 0, expDiff );
+        sigB = sig128Extra.v;
+        sigZExtra = sig128Extra.extra;
+    }
+ newlyAligned:
+    sigZ =
+        softfloat_add128(
+            sigA.v64 | UINT64_C( 0x0001000000000000 ),
+            sigA.v0,
+            sigB.v64,
+            sigB.v0
+        );
+    --expZ;
+    if ( sigZ.v64 < UINT64_C( 0x0002000000000000 ) ) goto roundAndPack;
+    ++expZ;
+ shiftRight1:
+    sig128Extra =
+        softfloat_shortShiftRightJam128Extra(
+            sigZ.v64, sigZ.v0, sigZExtra, 1 );
+    sigZ = sig128Extra.v;
+    sigZExtra = sig128Extra.extra;
+ roundAndPack:
+    return
+        softfloat_roundPackToF128( signZ, expZ, sigZ.v64, sigZ.v0, sigZExtra );
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_addMagsF16.c b/softfloat/source/s_addMagsF16.c
index b7fba09..abc42b8 100644
--- a/softfloat/source/s_addMagsF16.c
+++ b/softfloat/source/s_addMagsF16.c
@@ -1,183 +1,183 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    int_fast8_t expDiff;
-    uint_fast16_t uiZ;
-    bool signZ;
-    int_fast8_t expZ;
-    uint_fast16_t sigZ;
-    uint_fast16_t sigX, sigY;
-    int_fast8_t shiftDist;
-    uint_fast32_t sig32Z;
-    int_fast8_t roundingMode;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF16UI( uiA );
-    sigA = fracF16UI( uiA );
-    expB = expF16UI( uiB );
-    sigB = fracF16UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( ! expA ) {
-            uiZ = uiA + sigB;
-            goto uiZ;
-        }
-        if ( expA == 0x1F ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            uiZ = uiA;
-            goto uiZ;
-        }
-        signZ = signF16UI( uiA );
-        expZ = expA;
-        sigZ = 0x0800 + sigA + sigB;
-        if ( ! (sigZ & 1) && (expZ < 0x1E) ) {
-            sigZ >>= 1;
-            goto pack;
-        }
-        sigZ <<= 3;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signF16UI( uiA );
-        if ( expDiff < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            if ( expB == 0x1F ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF16UI( signZ, 0x1F, 0 );
-                goto uiZ;
-            }
-            if ( expDiff <= -13 ) {
-                uiZ = packToF16UI( signZ, expB, sigB );
-                if ( expA | sigA ) goto addEpsilon;
-                goto uiZ;
-            }
-            expZ = expB;
-            sigX = sigB | 0x0400;
-            sigY = sigA + (expA ? 0x0400 : sigA);
-            shiftDist = 19 + expDiff;
-        } else {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            uiZ = uiA;
-            if ( expA == 0x1F ) {
-                if ( sigA ) goto propagateNaN;
-                goto uiZ;
-            }
-            if ( 13 <= expDiff ) {
-                if ( expB | sigB ) goto addEpsilon;
-                goto uiZ;
-            }
-            expZ = expA;
-            sigX = sigA | 0x0400;
-            sigY = sigB + (expB ? 0x0400 : sigB);
-            shiftDist = 19 - expDiff;
-        }
-        sig32Z =
-            ((uint_fast32_t) sigX<<19) + ((uint_fast32_t) sigY<<shiftDist);
-        if ( sig32Z < 0x40000000 ) {
-            --expZ;
-            sig32Z <<= 1;
-        }
-        sigZ = sig32Z>>16;
-        if ( sig32Z & 0xFFFF ) {
-            sigZ |= 1;
-        } else {
-            if ( ! (sigZ & 0xF) && (expZ < 0x1E) ) {
-                sigZ >>= 4;
-                goto pack;
-            }
-        }
-    }
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- addEpsilon:
-    roundingMode = softfloat_roundingMode;
-    if ( roundingMode != softfloat_round_near_even ) {
-        if (
-            roundingMode
-                == (signF16UI( uiZ ) ? softfloat_round_min
-                        : softfloat_round_max)
-        ) {
-            ++uiZ;
-            if ( (uint16_t) (uiZ<<1) == 0xF800 ) {
-                softfloat_raiseFlags(
-                    softfloat_flag_overflow | softfloat_flag_inexact );
-            }
-        }
-#ifdef SOFTFLOAT_ROUND_ODD
-        else if ( roundingMode == softfloat_round_odd ) {
-            uiZ |= 1;
-        }
-#endif
-    }
-    softfloat_exceptionFlags |= softfloat_flag_inexact;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- pack:
-    uiZ = packToF16UI( signZ, expZ, sigZ );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t softfloat_addMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    int_fast8_t expDiff;
+    uint_fast16_t uiZ;
+    bool signZ;
+    int_fast8_t expZ;
+    uint_fast16_t sigZ;
+    uint_fast16_t sigX, sigY;
+    int_fast8_t shiftDist;
+    uint_fast32_t sig32Z;
+    int_fast8_t roundingMode;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF16UI( uiA );
+    sigA = fracF16UI( uiA );
+    expB = expF16UI( uiB );
+    sigB = fracF16UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( ! expA ) {
+            uiZ = uiA + sigB;
+            goto uiZ;
+        }
+        if ( expA == 0x1F ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            uiZ = uiA;
+            goto uiZ;
+        }
+        signZ = signF16UI( uiA );
+        expZ = expA;
+        sigZ = 0x0800 + sigA + sigB;
+        if ( ! (sigZ & 1) && (expZ < 0x1E) ) {
+            sigZ >>= 1;
+            goto pack;
+        }
+        sigZ <<= 3;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signF16UI( uiA );
+        if ( expDiff < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            if ( expB == 0x1F ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF16UI( signZ, 0x1F, 0 );
+                goto uiZ;
+            }
+            if ( expDiff <= -13 ) {
+                uiZ = packToF16UI( signZ, expB, sigB );
+                if ( expA | sigA ) goto addEpsilon;
+                goto uiZ;
+            }
+            expZ = expB;
+            sigX = sigB | 0x0400;
+            sigY = sigA + (expA ? 0x0400 : sigA);
+            shiftDist = 19 + expDiff;
+        } else {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            uiZ = uiA;
+            if ( expA == 0x1F ) {
+                if ( sigA ) goto propagateNaN;
+                goto uiZ;
+            }
+            if ( 13 <= expDiff ) {
+                if ( expB | sigB ) goto addEpsilon;
+                goto uiZ;
+            }
+            expZ = expA;
+            sigX = sigA | 0x0400;
+            sigY = sigB + (expB ? 0x0400 : sigB);
+            shiftDist = 19 - expDiff;
+        }
+        sig32Z =
+            ((uint_fast32_t) sigX<<19) + ((uint_fast32_t) sigY<<shiftDist);
+        if ( sig32Z < 0x40000000 ) {
+            --expZ;
+            sig32Z <<= 1;
+        }
+        sigZ = sig32Z>>16;
+        if ( sig32Z & 0xFFFF ) {
+            sigZ |= 1;
+        } else {
+            if ( ! (sigZ & 0xF) && (expZ < 0x1E) ) {
+                sigZ >>= 4;
+                goto pack;
+            }
+        }
+    }
+    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ addEpsilon:
+    roundingMode = softfloat_roundingMode;
+    if ( roundingMode != softfloat_round_near_even ) {
+        if (
+            roundingMode
+                == (signF16UI( uiZ ) ? softfloat_round_min
+                        : softfloat_round_max)
+        ) {
+            ++uiZ;
+            if ( (uint16_t) (uiZ<<1) == 0xF800 ) {
+                softfloat_raiseFlags(
+                    softfloat_flag_overflow | softfloat_flag_inexact );
+            }
+        }
+#ifdef SOFTFLOAT_ROUND_ODD
+        else if ( roundingMode == softfloat_round_odd ) {
+            uiZ |= 1;
+        }
+#endif
+    }
+    softfloat_exceptionFlags |= softfloat_flag_inexact;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ pack:
+    uiZ = packToF16UI( signZ, expZ, sigZ );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_addMagsF32.c b/softfloat/source/s_addMagsF32.c
index b74489d..ed85bb0 100644
--- a/softfloat/source/s_addMagsF32.c
+++ b/softfloat/source/s_addMagsF32.c
@@ -1,126 +1,126 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    int_fast16_t expDiff;
-    uint_fast32_t uiZ;
-    bool signZ;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF32UI( uiA );
-    sigA = fracF32UI( uiA );
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( ! expA ) {
-            uiZ = uiA + sigB;
-            goto uiZ;
-        }
-        if ( expA == 0xFF ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            uiZ = uiA;
-            goto uiZ;
-        }
-        signZ = signF32UI( uiA );
-        expZ = expA;
-        sigZ = 0x01000000 + sigA + sigB;
-        if ( ! (sigZ & 1) && (expZ < 0xFE) ) {
-            uiZ = packToF32UI( signZ, expZ, sigZ>>1 );
-            goto uiZ;
-        }
-        sigZ <<= 6;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signF32UI( uiA );
-        sigA <<= 6;
-        sigB <<= 6;
-        if ( expDiff < 0 ) {
-            if ( expB == 0xFF ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF32UI( signZ, 0xFF, 0 );
-                goto uiZ;
-            }
-            expZ = expB;
-            sigA += expA ? 0x20000000 : sigA;
-            sigA = softfloat_shiftRightJam32( sigA, -expDiff );
-        } else {
-            if ( expA == 0xFF ) {
-                if ( sigA ) goto propagateNaN;
-                uiZ = uiA;
-                goto uiZ;
-            }
-            expZ = expA;
-            sigB += expB ? 0x20000000 : sigB;
-            sigB = softfloat_shiftRightJam32( sigB, expDiff );
-        }
-        sigZ = 0x20000000 + sigA + sigB;
-        if ( sigZ < 0x40000000 ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    }
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+float32_t softfloat_addMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    int_fast16_t expDiff;
+    uint_fast32_t uiZ;
+    bool signZ;
+    int_fast16_t expZ;
+    uint_fast32_t sigZ;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF32UI( uiA );
+    sigA = fracF32UI( uiA );
+    expB = expF32UI( uiB );
+    sigB = fracF32UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( ! expA ) {
+            uiZ = uiA + sigB;
+            goto uiZ;
+        }
+        if ( expA == 0xFF ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            uiZ = uiA;
+            goto uiZ;
+        }
+        signZ = signF32UI( uiA );
+        expZ = expA;
+        sigZ = 0x01000000 + sigA + sigB;
+        if ( ! (sigZ & 1) && (expZ < 0xFE) ) {
+            uiZ = packToF32UI( signZ, expZ, sigZ>>1 );
+            goto uiZ;
+        }
+        sigZ <<= 6;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signF32UI( uiA );
+        sigA <<= 6;
+        sigB <<= 6;
+        if ( expDiff < 0 ) {
+            if ( expB == 0xFF ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF32UI( signZ, 0xFF, 0 );
+                goto uiZ;
+            }
+            expZ = expB;
+            sigA += expA ? 0x20000000 : sigA;
+            sigA = softfloat_shiftRightJam32( sigA, -expDiff );
+        } else {
+            if ( expA == 0xFF ) {
+                if ( sigA ) goto propagateNaN;
+                uiZ = uiA;
+                goto uiZ;
+            }
+            expZ = expA;
+            sigB += expB ? 0x20000000 : sigB;
+            sigB = softfloat_shiftRightJam32( sigB, expDiff );
+        }
+        sigZ = 0x20000000 + sigA + sigB;
+        if ( sigZ < 0x40000000 ) {
+            --expZ;
+            sigZ <<= 1;
+        }
+    }
+    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_addMagsF64.c b/softfloat/source/s_addMagsF64.c
index e8a4898..25b8f38 100644
--- a/softfloat/source/s_addMagsF64.c
+++ b/softfloat/source/s_addMagsF64.c
@@ -1,128 +1,128 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-float64_t
- softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
-{
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    int_fast16_t expDiff;
-    uint_fast64_t uiZ;
-    int_fast16_t expZ;
-    uint_fast64_t sigZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( ! expA ) {
-            uiZ = uiA + sigB;
-            goto uiZ;
-        }
-        if ( expA == 0x7FF ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            uiZ = uiA;
-            goto uiZ;
-        }
-        expZ = expA;
-        sigZ = UINT64_C( 0x0020000000000000 ) + sigA + sigB;
-        sigZ <<= 9;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sigA <<= 9;
-        sigB <<= 9;
-        if ( expDiff < 0 ) {
-            if ( expB == 0x7FF ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF64UI( signZ, 0x7FF, 0 );
-                goto uiZ;
-            }
-            expZ = expB;
-            if ( expA ) {
-                sigA += UINT64_C( 0x2000000000000000 );
-            } else {
-                sigA <<= 1;
-            }
-            sigA = softfloat_shiftRightJam64( sigA, -expDiff );
-        } else {
-            if ( expA == 0x7FF ) {
-                if ( sigA ) goto propagateNaN;
-                uiZ = uiA;
-                goto uiZ;
-            }
-            expZ = expA;
-            if ( expB ) {
-                sigB += UINT64_C( 0x2000000000000000 );
-            } else {
-                sigB <<= 1;
-            }
-            sigB = softfloat_shiftRightJam64( sigB, expDiff );
-        }
-        sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB;
-        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    }
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+float64_t
+ softfloat_addMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+{
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    int_fast16_t expDiff;
+    uint_fast64_t uiZ;
+    int_fast16_t expZ;
+    uint_fast64_t sigZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF64UI( uiA );
+    sigA = fracF64UI( uiA );
+    expB = expF64UI( uiB );
+    sigB = fracF64UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( ! expA ) {
+            uiZ = uiA + sigB;
+            goto uiZ;
+        }
+        if ( expA == 0x7FF ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            uiZ = uiA;
+            goto uiZ;
+        }
+        expZ = expA;
+        sigZ = UINT64_C( 0x0020000000000000 ) + sigA + sigB;
+        sigZ <<= 9;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sigA <<= 9;
+        sigB <<= 9;
+        if ( expDiff < 0 ) {
+            if ( expB == 0x7FF ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF64UI( signZ, 0x7FF, 0 );
+                goto uiZ;
+            }
+            expZ = expB;
+            if ( expA ) {
+                sigA += UINT64_C( 0x2000000000000000 );
+            } else {
+                sigA <<= 1;
+            }
+            sigA = softfloat_shiftRightJam64( sigA, -expDiff );
+        } else {
+            if ( expA == 0x7FF ) {
+                if ( sigA ) goto propagateNaN;
+                uiZ = uiA;
+                goto uiZ;
+            }
+            expZ = expA;
+            if ( expB ) {
+                sigB += UINT64_C( 0x2000000000000000 );
+            } else {
+                sigB <<= 1;
+            }
+            sigB = softfloat_shiftRightJam64( sigB, expDiff );
+        }
+        sigZ = UINT64_C( 0x2000000000000000 ) + sigA + sigB;
+        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
+            --expZ;
+            sigZ <<= 1;
+        }
+    }
+    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_approxRecip32_1.c b/softfloat/source/s_approxRecip32_1.c
index 4a326a4..f4fdbfe 100644
--- a/softfloat/source/s_approxRecip32_1.c
+++ b/softfloat/source/s_approxRecip32_1.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_approxRecip32_1
-
-extern const uint16_t softfloat_approxRecip_1k0s[16];
-extern const uint16_t softfloat_approxRecip_1k1s[16];
-
-uint32_t softfloat_approxRecip32_1( uint32_t a )
-{
-    int index;
-    uint16_t eps, r0;
-    uint32_t sigma0;
-    uint_fast32_t r;
-    uint32_t sqrSigma0;
-
-    index = a>>27 & 0xF;
-    eps = (uint16_t) (a>>11);
-    r0 = softfloat_approxRecip_1k0s[index]
-             - ((softfloat_approxRecip_1k1s[index] * (uint_fast32_t) eps)>>20);
-    sigma0 = ~(uint_fast32_t) ((r0 * (uint_fast64_t) a)>>7);
-    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>24);
-    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
-    r += ((uint32_t) r * (uint_fast64_t) sqrSigma0)>>48;
-    return r;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_approxRecip32_1
+
+extern const uint16_t softfloat_approxRecip_1k0s[16];
+extern const uint16_t softfloat_approxRecip_1k1s[16];
+
+uint32_t softfloat_approxRecip32_1( uint32_t a )
+{
+    int index;
+    uint16_t eps, r0;
+    uint32_t sigma0;
+    uint_fast32_t r;
+    uint32_t sqrSigma0;
+
+    index = a>>27 & 0xF;
+    eps = (uint16_t) (a>>11);
+    r0 = softfloat_approxRecip_1k0s[index]
+             - ((softfloat_approxRecip_1k1s[index] * (uint_fast32_t) eps)>>20);
+    sigma0 = ~(uint_fast32_t) ((r0 * (uint_fast64_t) a)>>7);
+    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>24);
+    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
+    r += ((uint32_t) r * (uint_fast64_t) sqrSigma0)>>48;
+    return r;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_approxRecipSqrt32_1.c b/softfloat/source/s_approxRecipSqrt32_1.c
index b3fdeba..28eca64 100644
--- a/softfloat/source/s_approxRecipSqrt32_1.c
+++ b/softfloat/source/s_approxRecipSqrt32_1.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_approxRecipSqrt32_1
-
-extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
-extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
-
-uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a )
-{
-    int index;
-    uint16_t eps, r0;
-    uint_fast32_t ESqrR0;
-    uint32_t sigma0;
-    uint_fast32_t r;
-    uint32_t sqrSigma0;
-
-    index = (a>>27 & 0xE) + oddExpA;
-    eps = (uint16_t) (a>>12);
-    r0 = softfloat_approxRecipSqrt_1k0s[index]
-             - ((softfloat_approxRecipSqrt_1k1s[index] * (uint_fast32_t) eps)
-                    >>20);
-    ESqrR0 = (uint_fast32_t) r0 * r0;
-    if ( ! oddExpA ) ESqrR0 <<= 1;
-    sigma0 = ~(uint_fast32_t) (((uint32_t) ESqrR0 * (uint_fast64_t) a)>>23);
-    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>25);
-    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
-    r += ((uint32_t) ((r>>1) + (r>>3) - ((uint_fast32_t) r0<<14))
-              * (uint_fast64_t) sqrSigma0)
-             >>48;
-    if ( ! (r & 0x80000000) ) r = 0x80000000;
-    return r;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_approxRecipSqrt32_1
+
+extern const uint16_t softfloat_approxRecipSqrt_1k0s[];
+extern const uint16_t softfloat_approxRecipSqrt_1k1s[];
+
+uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a )
+{
+    int index;
+    uint16_t eps, r0;
+    uint_fast32_t ESqrR0;
+    uint32_t sigma0;
+    uint_fast32_t r;
+    uint32_t sqrSigma0;
+
+    index = (a>>27 & 0xE) + oddExpA;
+    eps = (uint16_t) (a>>12);
+    r0 = softfloat_approxRecipSqrt_1k0s[index]
+             - ((softfloat_approxRecipSqrt_1k1s[index] * (uint_fast32_t) eps)
+                    >>20);
+    ESqrR0 = (uint_fast32_t) r0 * r0;
+    if ( ! oddExpA ) ESqrR0 <<= 1;
+    sigma0 = ~(uint_fast32_t) (((uint32_t) ESqrR0 * (uint_fast64_t) a)>>23);
+    r = ((uint_fast32_t) r0<<16) + ((r0 * (uint_fast64_t) sigma0)>>25);
+    sqrSigma0 = ((uint_fast64_t) sigma0 * sigma0)>>32;
+    r += ((uint32_t) ((r>>1) + (r>>3) - ((uint_fast32_t) r0<<14))
+              * (uint_fast64_t) sqrSigma0)
+             >>48;
+    if ( ! (r & 0x80000000) ) r = 0x80000000;
+    return r;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_approxRecipSqrt_1Ks.c b/softfloat/source/s_approxRecipSqrt_1Ks.c
index 38a2798..7a8663b 100644
--- a/softfloat/source/s_approxRecipSqrt_1Ks.c
+++ b/softfloat/source/s_approxRecipSqrt_1Ks.c
@@ -1,49 +1,49 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-const uint16_t softfloat_approxRecipSqrt_1k0s[16] = {
-    0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29,
-    0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1
-};
-const uint16_t softfloat_approxRecipSqrt_1k1s[16] = {
-    0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6,
-    0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD
-};
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+
+const uint16_t softfloat_approxRecipSqrt_1k0s[16] = {
+    0xB4C9, 0xFFAB, 0xAA7D, 0xF11C, 0xA1C5, 0xE4C7, 0x9A43, 0xDA29,
+    0x93B5, 0xD0E5, 0x8DED, 0xC8B7, 0x88C6, 0xC16D, 0x8424, 0xBAE1
+};
+const uint16_t softfloat_approxRecipSqrt_1k1s[16] = {
+    0xA5A5, 0xEA42, 0x8C21, 0xC62D, 0x788F, 0xAA7F, 0x6928, 0x94B6,
+    0x5CC7, 0x8335, 0x52A6, 0x74E2, 0x4A3E, 0x68FE, 0x432B, 0x5EFD
+};
+
diff --git a/softfloat/source/s_approxRecip_1Ks.c b/softfloat/source/s_approxRecip_1Ks.c
index f1fca74..54b1b0f 100644
--- a/softfloat/source/s_approxRecip_1Ks.c
+++ b/softfloat/source/s_approxRecip_1Ks.c
@@ -1,49 +1,49 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-const uint16_t softfloat_approxRecip_1k0s[16] = {
-    0xFFC4, 0xF0BE, 0xE363, 0xD76F, 0xCCAD, 0xC2F0, 0xBA16, 0xB201,
-    0xAA97, 0xA3C6, 0x9D7A, 0x97A6, 0x923C, 0x8D32, 0x887E, 0x8417
-};
-const uint16_t softfloat_approxRecip_1k1s[16] = {
-    0xF0F1, 0xD62C, 0xBFA1, 0xAC77, 0x9C0A, 0x8DDB, 0x8185, 0x76BA,
-    0x6D3B, 0x64D4, 0x5D5C, 0x56B1, 0x50B6, 0x4B55, 0x4679, 0x4211
-};
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+
+const uint16_t softfloat_approxRecip_1k0s[16] = {
+    0xFFC4, 0xF0BE, 0xE363, 0xD76F, 0xCCAD, 0xC2F0, 0xBA16, 0xB201,
+    0xAA97, 0xA3C6, 0x9D7A, 0x97A6, 0x923C, 0x8D32, 0x887E, 0x8417
+};
+const uint16_t softfloat_approxRecip_1k1s[16] = {
+    0xF0F1, 0xD62C, 0xBFA1, 0xAC77, 0x9C0A, 0x8DDB, 0x8185, 0x76BA,
+    0x6D3B, 0x64D4, 0x5D5C, 0x56B1, 0x50B6, 0x4B55, 0x4679, 0x4211
+};
+
diff --git a/softfloat/source/s_compare128M.c b/softfloat/source/s_compare128M.c
index dc97ce9..8f12182 100644
--- a/softfloat/source/s_compare128M.c
+++ b/softfloat/source/s_compare128M.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_compare128M
-
-int_fast8_t softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr )
-{
-    unsigned int index, lastIndex;
-    uint32_t wordA, wordB;
-
-    index = indexWordHi( 4 );
-    lastIndex = indexWordLo( 4 );
-    for (;;) {
-        wordA = aPtr[index];
-        wordB = bPtr[index];
-        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
-        if ( index == lastIndex ) break;
-        index -= wordIncr;
-    }
-    return 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_compare128M
+
+int_fast8_t softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr )
+{
+    unsigned int index, lastIndex;
+    uint32_t wordA, wordB;
+
+    index = indexWordHi( 4 );
+    lastIndex = indexWordLo( 4 );
+    for (;;) {
+        wordA = aPtr[index];
+        wordB = bPtr[index];
+        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
+        if ( index == lastIndex ) break;
+        index -= wordIncr;
+    }
+    return 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_compare96M.c b/softfloat/source/s_compare96M.c
index 2681c46..8fdf718 100644
--- a/softfloat/source/s_compare96M.c
+++ b/softfloat/source/s_compare96M.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_compare96M
-
-int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr )
-{
-    unsigned int index, lastIndex;
-    uint32_t wordA, wordB;
-
-    index = indexWordHi( 3 );
-    lastIndex = indexWordLo( 3 );
-    for (;;) {
-        wordA = aPtr[index];
-        wordB = bPtr[index];
-        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
-        if ( index == lastIndex ) break;
-        index -= wordIncr;
-    }
-    return 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_compare96M
+
+int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr )
+{
+    unsigned int index, lastIndex;
+    uint32_t wordA, wordB;
+
+    index = indexWordHi( 3 );
+    lastIndex = indexWordLo( 3 );
+    for (;;) {
+        wordA = aPtr[index];
+        wordB = bPtr[index];
+        if ( wordA != wordB ) return (wordA < wordB) ? -1 : 1;
+        if ( index == lastIndex ) break;
+        index -= wordIncr;
+    }
+    return 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_compareNonnormExtF80M.c b/softfloat/source/s_compareNonnormExtF80M.c
index 2673153..6712e57 100644
--- a/softfloat/source/s_compareNonnormExtF80M.c
+++ b/softfloat/source/s_compareNonnormExtF80M.c
@@ -1,111 +1,111 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat_types.h"
-
-int
- softfloat_compareNonnormExtF80M(
-     const struct extFloat80M *aSPtr, const struct extFloat80M *bSPtr )
-{
-    uint_fast16_t uiA64, uiB64;
-    uint64_t sigA;
-    bool signB;
-    uint64_t sigB;
-    int32_t expA, expB;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA64 = aSPtr->signExp;
-    uiB64 = bSPtr->signExp;
-    sigA = aSPtr->signif;
-    signB = signExtF80UI64( uiB64 );
-    sigB = bSPtr->signif;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( (uiA64 ^ uiB64) & 0x8000 ) {
-        if ( ! (sigA | sigB) ) return 0;
-        goto resultFromSignB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expExtF80UI64( uiA64 );
-    expB = expExtF80UI64( uiB64 );
-    if ( expA == 0x7FFF ) {
-        if (expB == 0x7FFF) return 0;
-        signB = ! signB;
-        goto resultFromSignB;
-    }
-    if ( expB == 0x7FFF ) {
-        goto resultFromSignB;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) expA = 1;
-    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
-        if ( sigA ) {
-            expA += softfloat_normExtF80SigM( &sigA );
-        } else {
-            expA = -128;
-        }
-    }
-    if ( ! expB ) expB = 1;
-    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
-        if ( sigB ) {
-            expB += softfloat_normExtF80SigM( &sigB );
-        } else {
-            expB = -128;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signB ) {
-        if ( expA < expB ) return 1;
-        if ( (expB < expA) || (sigB < sigA) ) return -1;
-    } else {
-        if ( expB < expA ) return 1;
-        if ( (expA < expB) || (sigA < sigB) ) return -1;
-    }
-    return (sigA != sigB);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- resultFromSignB:
-    return signB ? 1 : -1;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat_types.h"
+
+int
+ softfloat_compareNonnormExtF80M(
+     const struct extFloat80M *aSPtr, const struct extFloat80M *bSPtr )
+{
+    uint_fast16_t uiA64, uiB64;
+    uint64_t sigA;
+    bool signB;
+    uint64_t sigB;
+    int32_t expA, expB;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA64 = aSPtr->signExp;
+    uiB64 = bSPtr->signExp;
+    sigA = aSPtr->signif;
+    signB = signExtF80UI64( uiB64 );
+    sigB = bSPtr->signif;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( (uiA64 ^ uiB64) & 0x8000 ) {
+        if ( ! (sigA | sigB) ) return 0;
+        goto resultFromSignB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expExtF80UI64( uiA64 );
+    expB = expExtF80UI64( uiB64 );
+    if ( expA == 0x7FFF ) {
+        if (expB == 0x7FFF) return 0;
+        signB = ! signB;
+        goto resultFromSignB;
+    }
+    if ( expB == 0x7FFF ) {
+        goto resultFromSignB;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) expA = 1;
+    if ( ! (sigA & UINT64_C( 0x8000000000000000 )) ) {
+        if ( sigA ) {
+            expA += softfloat_normExtF80SigM( &sigA );
+        } else {
+            expA = -128;
+        }
+    }
+    if ( ! expB ) expB = 1;
+    if ( ! (sigB & UINT64_C( 0x8000000000000000 )) ) {
+        if ( sigB ) {
+            expB += softfloat_normExtF80SigM( &sigB );
+        } else {
+            expB = -128;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signB ) {
+        if ( expA < expB ) return 1;
+        if ( (expB < expA) || (sigB < sigA) ) return -1;
+    } else {
+        if ( expB < expA ) return 1;
+        if ( (expA < expB) || (sigA < sigB) ) return -1;
+    }
+    return (sigA != sigB);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ resultFromSignB:
+    return signB ? 1 : -1;
+
+}
+
diff --git a/softfloat/source/s_countLeadingZeros16.c b/softfloat/source/s_countLeadingZeros16.c
index 7a68da5..af2831c 100644
--- a/softfloat/source/s_countLeadingZeros16.c
+++ b/softfloat/source/s_countLeadingZeros16.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_countLeadingZeros16
-
-#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16
-#include "primitives.h"
-
-uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
-{
-    uint_fast8_t count;
-
-    count = 8;
-    if ( 0x100 <= a ) {
-        count = 0;
-        a >>= 8;
-    }
-    count += softfloat_countLeadingZeros8[a];
-    return count;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_countLeadingZeros16
+
+#define softfloat_countLeadingZeros16 softfloat_countLeadingZeros16
+#include "primitives.h"
+
+uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
+{
+    uint_fast8_t count;
+
+    count = 8;
+    if ( 0x100 <= a ) {
+        count = 0;
+        a >>= 8;
+    }
+    count += softfloat_countLeadingZeros8[a];
+    return count;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_countLeadingZeros32.c b/softfloat/source/s_countLeadingZeros32.c
index 53ab228..a7c50cd 100644
--- a/softfloat/source/s_countLeadingZeros32.c
+++ b/softfloat/source/s_countLeadingZeros32.c
@@ -1,64 +1,64 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_countLeadingZeros32
-
-#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32
-#include "primitives.h"
-
-uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )
-{
-    uint_fast8_t count;
-
-    count = 0;
-    if ( a < 0x10000 ) {
-        count = 16;
-        a <<= 16;
-    }
-    if ( a < 0x1000000 ) {
-        count += 8;
-        a <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[a>>24];
-    return count;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_countLeadingZeros32
+
+#define softfloat_countLeadingZeros32 softfloat_countLeadingZeros32
+#include "primitives.h"
+
+uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )
+{
+    uint_fast8_t count;
+
+    count = 0;
+    if ( a < 0x10000 ) {
+        count = 16;
+        a <<= 16;
+    }
+    if ( a < 0x1000000 ) {
+        count += 8;
+        a <<= 8;
+    }
+    count += softfloat_countLeadingZeros8[a>>24];
+    return count;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_countLeadingZeros64.c b/softfloat/source/s_countLeadingZeros64.c
index 13a2224..34745b1 100644
--- a/softfloat/source/s_countLeadingZeros64.c
+++ b/softfloat/source/s_countLeadingZeros64.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_countLeadingZeros64
-
-#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64
-#include "primitives.h"
-
-uint_fast8_t softfloat_countLeadingZeros64( uint64_t a )
-{
-    uint_fast8_t count;
-    uint32_t a32;
-
-    count = 0;
-    a32 = a>>32;
-    if ( ! a32 ) {
-        count = 32;
-        a32 = a;
-    }
-    /*------------------------------------------------------------------------
-    | From here, result is current count + count leading zeros of `a32'.
-    *------------------------------------------------------------------------*/
-    if ( a32 < 0x10000 ) {
-        count += 16;
-        a32 <<= 16;
-    }
-    if ( a32 < 0x1000000 ) {
-        count += 8;
-        a32 <<= 8;
-    }
-    count += softfloat_countLeadingZeros8[a32>>24];
-    return count;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_countLeadingZeros64
+
+#define softfloat_countLeadingZeros64 softfloat_countLeadingZeros64
+#include "primitives.h"
+
+uint_fast8_t softfloat_countLeadingZeros64( uint64_t a )
+{
+    uint_fast8_t count;
+    uint32_t a32;
+
+    count = 0;
+    a32 = a>>32;
+    if ( ! a32 ) {
+        count = 32;
+        a32 = a;
+    }
+    /*------------------------------------------------------------------------
+    | From here, result is current count + count leading zeros of `a32'.
+    *------------------------------------------------------------------------*/
+    if ( a32 < 0x10000 ) {
+        count += 16;
+        a32 <<= 16;
+    }
+    if ( a32 < 0x1000000 ) {
+        count += 8;
+        a32 <<= 8;
+    }
+    count += softfloat_countLeadingZeros8[a32>>24];
+    return count;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_countLeadingZeros8.c b/softfloat/source/s_countLeadingZeros8.c
index a56f5a4..0cc60a1 100644
--- a/softfloat/source/s_countLeadingZeros8.c
+++ b/softfloat/source/s_countLeadingZeros8.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-const uint_least8_t softfloat_countLeadingZeros8[256] = {
-    8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+
+const uint_least8_t softfloat_countLeadingZeros8[256] = {
+    8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,
+    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
diff --git a/softfloat/source/s_eq128.c b/softfloat/source/s_eq128.c
index 275b8ae..1ccc243 100644
--- a/softfloat/source/s_eq128.c
+++ b/softfloat/source/s_eq128.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_eq128
-
-bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-
-    return (a64 == b64) && (a0 == b0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_eq128
+
+bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+
+    return (a64 == b64) && (a0 == b0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_invalidExtF80M.c b/softfloat/source/s_invalidExtF80M.c
index 237d217..d330478 100644
--- a/softfloat/source/s_invalidExtF80M.c
+++ b/softfloat/source/s_invalidExtF80M.c
@@ -1,49 +1,49 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include "platform.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-void softfloat_invalidExtF80M( struct extFloat80M *zSPtr )
-{
-
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif  = defaultNaNExtF80UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include "platform.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void softfloat_invalidExtF80M( struct extFloat80M *zSPtr )
+{
+
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    zSPtr->signExp = defaultNaNExtF80UI64;
+    zSPtr->signif  = defaultNaNExtF80UI0;
+
+}
+
diff --git a/softfloat/source/s_invalidF128M.c b/softfloat/source/s_invalidF128M.c
index a20840e..ee63cc3 100644
--- a/softfloat/source/s_invalidF128M.c
+++ b/softfloat/source/s_invalidF128M.c
@@ -1,53 +1,53 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-void softfloat_invalidF128M( uint32_t *zWPtr )
-{
-
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
-    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
-    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
-    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void softfloat_invalidF128M( uint32_t *zWPtr )
+{
+
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
+    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
+    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
+    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+
+}
+
diff --git a/softfloat/source/s_isNaNF128M.c b/softfloat/source/s_isNaNF128M.c
index 6008cf3..c73e49b 100644
--- a/softfloat/source/s_isNaNF128M.c
+++ b/softfloat/source/s_isNaNF128M.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "primitives.h"
-
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-bool softfloat_isNaNF128M( const uint32_t *aWPtr )
-{
-    uint32_t uiA96;
-
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    if ( (~uiA96 & 0x7FFF0000) != 0 ) return false;
-    return
-        ((uiA96 & 0x0000FFFF) != 0)
-            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
-                     | aWPtr[indexWord( 4, 0 )])
-                    != 0);
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "primitives.h"
+
+/*----------------------------------------------------------------------------
+*----------------------------------------------------------------------------*/
+bool softfloat_isNaNF128M( const uint32_t *aWPtr )
+{
+    uint32_t uiA96;
+
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    if ( (~uiA96 & 0x7FFF0000) != 0 ) return false;
+    return
+        ((uiA96 & 0x0000FFFF) != 0)
+            || ((aWPtr[indexWord( 4, 2 )] | aWPtr[indexWord( 4, 1 )]
+                     | aWPtr[indexWord( 4, 0 )])
+                    != 0);
+
+}
+
diff --git a/softfloat/source/s_le128.c b/softfloat/source/s_le128.c
index 1fce7af..da3d624 100644
--- a/softfloat/source/s_le128.c
+++ b/softfloat/source/s_le128.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_le128
-
-bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-
-    return (a64 < b64) || ((a64 == b64) && (a0 <= b0));
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_le128
+
+bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+
+    return (a64 < b64) || ((a64 == b64) && (a0 <= b0));
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_lt128.c b/softfloat/source/s_lt128.c
index d7ce3b9..b781991 100644
--- a/softfloat/source/s_lt128.c
+++ b/softfloat/source/s_lt128.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_lt128
-
-bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-
-    return (a64 < b64) || ((a64 == b64) && (a0 < b0));
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_lt128
+
+bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+
+    return (a64 < b64) || ((a64 == b64) && (a0 < b0));
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul128By32.c b/softfloat/source/s_mul128By32.c
index 7c0fdc8..df32ee7 100644
--- a/softfloat/source/s_mul128By32.c
+++ b/softfloat/source/s_mul128By32.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_mul128By32
-
-struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )
-{
-    struct uint128 z;
-    uint_fast64_t mid;
-    uint_fast32_t carry;
-
-    z.v0 = a0 * b;
-    mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;
-    carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);
-    z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_mul128By32
+
+struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )
+{
+    struct uint128 z;
+    uint_fast64_t mid;
+    uint_fast32_t carry;
+
+    z.v0 = a0 * b;
+    mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;
+    carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);
+    z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul128MTo256M.c b/softfloat/source/s_mul128MTo256M.c
index ea8865e..68d272e 100644
--- a/softfloat/source/s_mul128MTo256M.c
+++ b/softfloat/source/s_mul128MTo256M.c
@@ -1,100 +1,100 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_mul128MTo256M
-
-void
- softfloat_mul128MTo256M(
-     const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr )
-{
-    uint32_t *lastZPtr, wordB;
-    uint64_t dwordProd;
-    uint32_t wordZ;
-    uint_fast8_t carry;
-
-    bPtr += indexWordLo( 4 );
-    lastZPtr = zPtr + indexMultiwordHi( 8, 5 );
-    zPtr += indexMultiwordLo( 8, 5 );
-    wordB = *bPtr;
-    dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
-    zPtr[indexWord( 5, 0 )] = dwordProd;
-    dwordProd = (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
-    zPtr[indexWord( 5, 1 )] = dwordProd;
-    dwordProd = (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
-    zPtr[indexWord( 5, 2 )] = dwordProd;
-    dwordProd = (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
-    zPtr[indexWord( 5, 3 )] = dwordProd;
-    zPtr[indexWord( 5, 4 )] = dwordProd>>32;
-    do {
-        bPtr += wordIncr;
-        zPtr += wordIncr;
-        wordB = *bPtr;
-        dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
-        wordZ = zPtr[indexWord( 5, 0 )] + (uint32_t) dwordProd;
-        zPtr[indexWord( 5, 0 )] = wordZ;
-        carry = (wordZ < (uint32_t) dwordProd);
-        dwordProd =
-            (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
-        wordZ = zPtr[indexWord( 5, 1 )] + (uint32_t) dwordProd + carry;
-        zPtr[indexWord( 5, 1 )] = wordZ;
-        if ( wordZ != (uint32_t) dwordProd ) {
-            carry = (wordZ < (uint32_t) dwordProd);
-        }
-        dwordProd =
-            (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
-        wordZ = zPtr[indexWord( 5, 2 )] + (uint32_t) dwordProd + carry;
-        zPtr[indexWord( 5, 2 )] = wordZ;
-        if ( wordZ != (uint32_t) dwordProd ) {
-            carry = (wordZ < (uint32_t) dwordProd);
-        }
-        dwordProd =
-            (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
-        wordZ = zPtr[indexWord( 5, 3 )] + (uint32_t) dwordProd + carry;
-        zPtr[indexWord( 5, 3 )] = wordZ;
-        if ( wordZ != (uint32_t) dwordProd ) {
-            carry = (wordZ < (uint32_t) dwordProd);
-        }
-        zPtr[indexWord( 5, 4 )] = (dwordProd>>32) + carry;
-    } while ( zPtr != lastZPtr );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_mul128MTo256M
+
+void
+ softfloat_mul128MTo256M(
+     const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr )
+{
+    uint32_t *lastZPtr, wordB;
+    uint64_t dwordProd;
+    uint32_t wordZ;
+    uint_fast8_t carry;
+
+    bPtr += indexWordLo( 4 );
+    lastZPtr = zPtr + indexMultiwordHi( 8, 5 );
+    zPtr += indexMultiwordLo( 8, 5 );
+    wordB = *bPtr;
+    dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
+    zPtr[indexWord( 5, 0 )] = dwordProd;
+    dwordProd = (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
+    zPtr[indexWord( 5, 1 )] = dwordProd;
+    dwordProd = (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
+    zPtr[indexWord( 5, 2 )] = dwordProd;
+    dwordProd = (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
+    zPtr[indexWord( 5, 3 )] = dwordProd;
+    zPtr[indexWord( 5, 4 )] = dwordProd>>32;
+    do {
+        bPtr += wordIncr;
+        zPtr += wordIncr;
+        wordB = *bPtr;
+        dwordProd = (uint64_t) aPtr[indexWord( 4, 0 )] * wordB;
+        wordZ = zPtr[indexWord( 5, 0 )] + (uint32_t) dwordProd;
+        zPtr[indexWord( 5, 0 )] = wordZ;
+        carry = (wordZ < (uint32_t) dwordProd);
+        dwordProd =
+            (uint64_t) aPtr[indexWord( 4, 1 )] * wordB + (dwordProd>>32);
+        wordZ = zPtr[indexWord( 5, 1 )] + (uint32_t) dwordProd + carry;
+        zPtr[indexWord( 5, 1 )] = wordZ;
+        if ( wordZ != (uint32_t) dwordProd ) {
+            carry = (wordZ < (uint32_t) dwordProd);
+        }
+        dwordProd =
+            (uint64_t) aPtr[indexWord( 4, 2 )] * wordB + (dwordProd>>32);
+        wordZ = zPtr[indexWord( 5, 2 )] + (uint32_t) dwordProd + carry;
+        zPtr[indexWord( 5, 2 )] = wordZ;
+        if ( wordZ != (uint32_t) dwordProd ) {
+            carry = (wordZ < (uint32_t) dwordProd);
+        }
+        dwordProd =
+            (uint64_t) aPtr[indexWord( 4, 3 )] * wordB + (dwordProd>>32);
+        wordZ = zPtr[indexWord( 5, 3 )] + (uint32_t) dwordProd + carry;
+        zPtr[indexWord( 5, 3 )] = wordZ;
+        if ( wordZ != (uint32_t) dwordProd ) {
+            carry = (wordZ < (uint32_t) dwordProd);
+        }
+        zPtr[indexWord( 5, 4 )] = (dwordProd>>32) + carry;
+    } while ( zPtr != lastZPtr );
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul128To256M.c b/softfloat/source/s_mul128To256M.c
index 7c9d9b5..91df8f2 100644
--- a/softfloat/source/s_mul128To256M.c
+++ b/softfloat/source/s_mul128To256M.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_mul128To256M
-
-#define softfloat_mul128To256M softfloat_mul128To256M
-#include "primitives.h"
-
-void
- softfloat_mul128To256M(
-     uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr )
-{
-    struct uint128 p0, p64, p128;
-    uint_fast64_t z64, z128, z192;
-
-    p0 = softfloat_mul64To128( a0, b0 );
-    zPtr[indexWord( 4, 0 )] = p0.v0;
-    p64 = softfloat_mul64To128( a64, b0 );
-    z64 = p64.v0 + p0.v64;
-    z128 = p64.v64 + (z64 < p64.v0);
-    p128 = softfloat_mul64To128( a64, b64 );
-    z128 += p128.v0;
-    z192 = p128.v64 + (z128 < p128.v0);
-    p64 = softfloat_mul64To128( a0, b64 );
-    z64 += p64.v0;
-    zPtr[indexWord( 4, 1 )] = z64;
-    p64.v64 += (z64 < p64.v0);
-    z128 += p64.v64;
-    zPtr[indexWord( 4, 2 )] = z128;
-    zPtr[indexWord( 4, 3 )] = z192 + (z128 < p64.v64);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_mul128To256M
+
+#define softfloat_mul128To256M softfloat_mul128To256M
+#include "primitives.h"
+
+void
+ softfloat_mul128To256M(
+     uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr )
+{
+    struct uint128 p0, p64, p128;
+    uint_fast64_t z64, z128, z192;
+
+    p0 = softfloat_mul64To128( a0, b0 );
+    zPtr[indexWord( 4, 0 )] = p0.v0;
+    p64 = softfloat_mul64To128( a64, b0 );
+    z64 = p64.v0 + p0.v64;
+    z128 = p64.v64 + (z64 < p64.v0);
+    p128 = softfloat_mul64To128( a64, b64 );
+    z128 += p128.v0;
+    z192 = p128.v64 + (z128 < p128.v0);
+    p64 = softfloat_mul64To128( a0, b64 );
+    z64 += p64.v0;
+    zPtr[indexWord( 4, 1 )] = z64;
+    p64.v64 += (z64 < p64.v0);
+    z128 += p64.v64;
+    zPtr[indexWord( 4, 2 )] = z128;
+    zPtr[indexWord( 4, 3 )] = z192 + (z128 < p64.v64);
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul64ByShifted32To128.c b/softfloat/source/s_mul64ByShifted32To128.c
index 57e5288..ea8d486 100644
--- a/softfloat/source/s_mul64ByShifted32To128.c
+++ b/softfloat/source/s_mul64ByShifted32To128.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_mul64ByShifted32To128
-
-struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )
-{
-    uint_fast64_t mid;
-    struct uint128 z;
-
-    mid = (uint_fast64_t) (uint32_t) a * b;
-    z.v0 = mid<<32;
-    z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_mul64ByShifted32To128
+
+struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )
+{
+    uint_fast64_t mid;
+    struct uint128 z;
+
+    mid = (uint_fast64_t) (uint32_t) a * b;
+    z.v0 = mid<<32;
+    z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul64To128.c b/softfloat/source/s_mul64To128.c
index 5d360aa..0a3c2b9 100644
--- a/softfloat/source/s_mul64To128.c
+++ b/softfloat/source/s_mul64To128.c
@@ -1,66 +1,66 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_mul64To128
-
-struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )
-{
-    uint32_t a32, a0, b32, b0;
-    struct uint128 z;
-    uint64_t mid1, mid;
-
-    a32 = a>>32;
-    a0 = a;
-    b32 = b>>32;
-    b0 = b;
-    z.v0 = (uint_fast64_t) a0 * b0;
-    mid1 = (uint_fast64_t) a32 * b0;
-    mid = mid1 + (uint_fast64_t) a0 * b32;
-    z.v64 = (uint_fast64_t) a32 * b32;
-    z.v64 += (uint_fast64_t) (mid < mid1)<<32 | mid>>32;
-    mid <<= 32;
-    z.v0 += mid;
-    z.v64 += (z.v0 < mid);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_mul64To128
+
+struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b )
+{
+    uint32_t a32, a0, b32, b0;
+    struct uint128 z;
+    uint64_t mid1, mid;
+
+    a32 = a>>32;
+    a0 = a;
+    b32 = b>>32;
+    b0 = b;
+    z.v0 = (uint_fast64_t) a0 * b0;
+    mid1 = (uint_fast64_t) a32 * b0;
+    mid = mid1 + (uint_fast64_t) a0 * b32;
+    z.v64 = (uint_fast64_t) a32 * b32;
+    z.v64 += (uint_fast64_t) (mid < mid1)<<32 | mid>>32;
+    mid <<= 32;
+    z.v0 += mid;
+    z.v64 += (z.v0 < mid);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mul64To128M.c b/softfloat/source/s_mul64To128M.c
index ed10be3..cd15289 100644
--- a/softfloat/source/s_mul64To128M.c
+++ b/softfloat/source/s_mul64To128M.c
@@ -1,68 +1,68 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_mul64To128M
-
-void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr )
-{
-    uint32_t a32, a0, b32, b0;
-    uint64_t z0, mid1, z64, mid;
-
-    a32 = a>>32;
-    a0 = a;
-    b32 = b>>32;
-    b0 = b;
-    z0 = (uint64_t) a0 * b0;
-    mid1 = (uint64_t) a32 * b0;
-    mid = mid1 + (uint64_t) a0 * b32;
-    z64 = (uint64_t) a32 * b32;
-    z64 += (uint64_t) (mid < mid1)<<32 | mid>>32;
-    mid <<= 32;
-    z0 += mid;
-    zPtr[indexWord( 4, 1 )] = z0>>32;
-    zPtr[indexWord( 4, 0 )] = z0;
-    z64 += (z0 < mid);
-    zPtr[indexWord( 4, 3 )] = z64>>32;
-    zPtr[indexWord( 4, 2 )] = z64;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_mul64To128M
+
+void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr )
+{
+    uint32_t a32, a0, b32, b0;
+    uint64_t z0, mid1, z64, mid;
+
+    a32 = a>>32;
+    a0 = a;
+    b32 = b>>32;
+    b0 = b;
+    z0 = (uint64_t) a0 * b0;
+    mid1 = (uint64_t) a32 * b0;
+    mid = mid1 + (uint64_t) a0 * b32;
+    z64 = (uint64_t) a32 * b32;
+    z64 += (uint64_t) (mid < mid1)<<32 | mid>>32;
+    mid <<= 32;
+    z0 += mid;
+    zPtr[indexWord( 4, 1 )] = z0>>32;
+    zPtr[indexWord( 4, 0 )] = z0;
+    z64 += (z0 < mid);
+    zPtr[indexWord( 4, 3 )] = z64>>32;
+    zPtr[indexWord( 4, 2 )] = z64;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_mulAddF128.c b/softfloat/source/s_mulAddF128.c
index f6b2b45..9b98b9f 100644
--- a/softfloat/source/s_mulAddF128.c
+++ b/softfloat/source/s_mulAddF128.c
@@ -1,350 +1,350 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t
- softfloat_mulAddF128(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0,
-     uint_fast64_t uiC64,
-     uint_fast64_t uiC0,
-     uint_fast8_t op
- )
-{
-    bool signA;
-    int_fast32_t expA;
-    struct uint128 sigA;
-    bool signB;
-    int_fast32_t expB;
-    struct uint128 sigB;
-    bool signC;
-    int_fast32_t expC;
-    struct uint128 sigC;
-    bool signZ;
-    uint_fast64_t magBits;
-    struct uint128 uiZ;
-    struct exp32_sig128 normExpSig;
-    int_fast32_t expZ;
-    uint64_t sig256Z[4];
-    struct uint128 sigZ;
-    int_fast32_t shiftDist, expDiff;
-    struct uint128 x128;
-    uint64_t sig256C[4];
-    static uint64_t zero256[4] = INIT_UINTM4( 0, 0, 0, 0 );
-    uint_fast64_t sigZExtra, sig256Z0;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signF128UI64( uiA64 );
-    expA  = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    signB = signF128UI64( uiB64 );
-    expB  = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    signC = signF128UI64( uiC64 ) ^ (op == softfloat_mulAdd_subC);
-    expC  = expF128UI64( uiC64 );
-    sigC.v64 = fracF128UI64( uiC64 );
-    sigC.v0  = uiC0;
-    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FFF ) {
-        if (
-            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
-        ) {
-            goto propagateNaN_ABC;
-        }
-        magBits = expB | sigB.v64 | sigB.v0;
-        goto infProdArg;
-    }
-    if ( expB == 0x7FFF ) {
-        if ( sigB.v64 | sigB.v0 ) goto propagateNaN_ABC;
-        magBits = expA | sigA.v64 | sigA.v0;
-        goto infProdArg;
-    }
-    if ( expC == 0x7FFF ) {
-        if ( sigC.v64 | sigC.v0 ) {
-            uiZ.v64 = 0;
-            uiZ.v0  = 0;
-            goto propagateNaN_ZC;
-        }
-        uiZ.v64 = uiC64;
-        uiZ.v0  = uiC0;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! (sigA.v64 | sigA.v0) ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! (sigB.v64 | sigB.v0) ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FFE;
-    sigA.v64 |= UINT64_C( 0x0001000000000000 );
-    sigB.v64 |= UINT64_C( 0x0001000000000000 );
-    sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 8 );
-    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 15 );
-    softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z );
-    sigZ.v64 = sig256Z[indexWord( 4, 3 )];
-    sigZ.v0  = sig256Z[indexWord( 4, 2 )];
-    shiftDist = 0;
-    if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
-        --expZ;
-        shiftDist = -1;
-    }
-    if ( ! expC ) {
-        if ( ! (sigC.v64 | sigC.v0) ) {
-            shiftDist += 8;
-            goto sigZ;
-        }
-        normExpSig = softfloat_normSubnormalF128Sig( sigC.v64, sigC.v0 );
-        expC = normExpSig.exp;
-        sigC = normExpSig.sig;
-    }
-    sigC.v64 |= UINT64_C( 0x0001000000000000 );
-    sigC = softfloat_shortShiftLeft128( sigC.v64, sigC.v0, 8 );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expZ - expC;
-    if ( expDiff < 0 ) {
-        expZ = expC;
-        if ( (signZ == signC) || (expDiff < -1) ) {
-            shiftDist -= expDiff;
-            if ( shiftDist ) {
-                sigZ =
-                    softfloat_shiftRightJam128( sigZ.v64, sigZ.v0, shiftDist );
-            }
-        } else {
-            if ( ! shiftDist ) {
-                x128 =
-                    softfloat_shortShiftRight128(
-                        sig256Z[indexWord( 4, 1 )], sig256Z[indexWord( 4, 0 )],
-                        1
-                    );
-                sig256Z[indexWord( 4, 1 )] = (sigZ.v0<<63) | x128.v64;
-                sig256Z[indexWord( 4, 0 )] = x128.v0;
-                sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, 1 );
-                sig256Z[indexWord( 4, 3 )] = sigZ.v64;
-                sig256Z[indexWord( 4, 2 )] = sigZ.v0;
-            }
-        }
-    } else {
-        if ( shiftDist ) softfloat_add256M( sig256Z, sig256Z, sig256Z );
-        if ( ! expDiff ) {
-            sigZ.v64 = sig256Z[indexWord( 4, 3 )];
-            sigZ.v0  = sig256Z[indexWord( 4, 2 )];
-        } else {
-            sig256C[indexWord( 4, 3 )] = sigC.v64;
-            sig256C[indexWord( 4, 2 )] = sigC.v0;
-            sig256C[indexWord( 4, 1 )] = 0;
-            sig256C[indexWord( 4, 0 )] = 0;
-            softfloat_shiftRightJam256M( sig256C, expDiff, sig256C );
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    shiftDist = 8;
-    if ( signZ == signC ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff <= 0 ) {
-            sigZ = softfloat_add128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );
-        } else {
-            softfloat_add256M( sig256Z, sig256C, sig256Z );
-            sigZ.v64 = sig256Z[indexWord( 4, 3 )];
-            sigZ.v0  = sig256Z[indexWord( 4, 2 )];
-        }
-        if ( sigZ.v64 & UINT64_C( 0x0200000000000000 ) ) {
-            ++expZ;
-            shiftDist = 9;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff < 0 ) {
-            signZ = signC;
-            if ( expDiff < -1 ) {
-                sigZ =
-                    softfloat_sub128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );
-                sigZExtra =
-                    sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];
-                if ( sigZExtra ) {
-                    sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 );
-                }
-                if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
-                    --expZ;
-                    shiftDist = 7;
-                }
-                goto shiftRightRoundPack;
-            } else {
-                sig256C[indexWord( 4, 3 )] = sigC.v64;
-                sig256C[indexWord( 4, 2 )] = sigC.v0;
-                sig256C[indexWord( 4, 1 )] = 0;
-                sig256C[indexWord( 4, 0 )] = 0;
-                softfloat_sub256M( sig256C, sig256Z, sig256Z );
-            }
-        } else if ( ! expDiff ) {
-            sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, sigC.v64, sigC.v0 );
-            if (
-                ! (sigZ.v64 | sigZ.v0) && ! sig256Z[indexWord( 4, 1 )]
-                    && ! sig256Z[indexWord( 4, 0 )]
-            ) {
-                goto completeCancellation;
-            }
-            sig256Z[indexWord( 4, 3 )] = sigZ.v64;
-            sig256Z[indexWord( 4, 2 )] = sigZ.v0;
-            if ( sigZ.v64 & UINT64_C( 0x8000000000000000 ) ) {
-                signZ = ! signZ;
-                softfloat_sub256M( zero256, sig256Z, sig256Z );
-            }
-        } else {
-            softfloat_sub256M( sig256Z, sig256C, sig256Z );
-            if ( 1 < expDiff ) {
-                sigZ.v64 = sig256Z[indexWord( 4, 3 )];
-                sigZ.v0  = sig256Z[indexWord( 4, 2 )];
-                if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
-                    --expZ;
-                    shiftDist = 7;
-                }
-                goto sigZ;
-            }
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sigZ.v64  = sig256Z[indexWord( 4, 3 )];
-        sigZ.v0   = sig256Z[indexWord( 4, 2 )];
-        sigZExtra = sig256Z[indexWord( 4, 1 )];
-        sig256Z0  = sig256Z[indexWord( 4, 0 )];
-        if ( sigZ.v64 ) {
-            if ( sig256Z0 ) sigZExtra |= 1;
-        } else {
-            expZ -= 64;
-            sigZ.v64  = sigZ.v0;
-            sigZ.v0   = sigZExtra;
-            sigZExtra = sig256Z0;
-            if ( ! sigZ.v64 ) {
-                expZ -= 64;
-                sigZ.v64  = sigZ.v0;
-                sigZ.v0   = sigZExtra;
-                sigZExtra = 0;
-                if ( ! sigZ.v64 ) {
-                    expZ -= 64;
-                    sigZ.v64 = sigZ.v0;
-                    sigZ.v0  = 0;
-                }
-            }
-        }
-        shiftDist = softfloat_countLeadingZeros64( sigZ.v64 );
-        expZ += 7 - shiftDist;
-        shiftDist = 15 - shiftDist;
-        if ( 0 < shiftDist ) goto shiftRightRoundPack;
-        if ( shiftDist ) {
-            shiftDist = -shiftDist;
-            sigZ = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, shiftDist );
-            x128 = softfloat_shortShiftLeft128( 0, sigZExtra, shiftDist );
-            sigZ.v0 |= x128.v64;
-            sigZExtra = x128.v0;
-        }
-        goto roundPack;
-    }
- sigZ:
-    sigZExtra = sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];
- shiftRightRoundPack:
-    sigZExtra = (uint64_t) (sigZ.v0<<(64 - shiftDist)) | (sigZExtra != 0);
-    sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, shiftDist );
- roundPack:
-    return
-        softfloat_roundPackToF128(
-            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
-    goto propagateNaN_ZC;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infProdArg:
-    if ( magBits ) {
-        uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
-        uiZ.v0 = 0;
-        if ( expC != 0x7FFF ) goto uiZ;
-        if ( sigC.v64 | sigC.v0 ) goto propagateNaN_ZC;
-        if ( signZ == signC ) goto uiZ;
-    }
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
- propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    uiZ.v64 = uiC64;
-    uiZ.v0  = uiC0;
-    if ( ! (expC | sigC.v64 | sigC.v0) && (signZ != signC) ) {
- completeCancellation:
-        uiZ.v64 =
-            packToF128UI64(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-        uiZ.v0 = 0;
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t
+ softfloat_mulAddF128(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0,
+     uint_fast64_t uiC64,
+     uint_fast64_t uiC0,
+     uint_fast8_t op
+ )
+{
+    bool signA;
+    int_fast32_t expA;
+    struct uint128 sigA;
+    bool signB;
+    int_fast32_t expB;
+    struct uint128 sigB;
+    bool signC;
+    int_fast32_t expC;
+    struct uint128 sigC;
+    bool signZ;
+    uint_fast64_t magBits;
+    struct uint128 uiZ;
+    struct exp32_sig128 normExpSig;
+    int_fast32_t expZ;
+    uint64_t sig256Z[4];
+    struct uint128 sigZ;
+    int_fast32_t shiftDist, expDiff;
+    struct uint128 x128;
+    uint64_t sig256C[4];
+    static uint64_t zero256[4] = INIT_UINTM4( 0, 0, 0, 0 );
+    uint_fast64_t sigZExtra, sig256Z0;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signF128UI64( uiA64 );
+    expA  = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    signB = signF128UI64( uiB64 );
+    expB  = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    signC = signF128UI64( uiC64 ) ^ (op == softfloat_mulAdd_subC);
+    expC  = expF128UI64( uiC64 );
+    sigC.v64 = fracF128UI64( uiC64 );
+    sigC.v0  = uiC0;
+    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FFF ) {
+        if (
+            (sigA.v64 | sigA.v0) || ((expB == 0x7FFF) && (sigB.v64 | sigB.v0))
+        ) {
+            goto propagateNaN_ABC;
+        }
+        magBits = expB | sigB.v64 | sigB.v0;
+        goto infProdArg;
+    }
+    if ( expB == 0x7FFF ) {
+        if ( sigB.v64 | sigB.v0 ) goto propagateNaN_ABC;
+        magBits = expA | sigA.v64 | sigA.v0;
+        goto infProdArg;
+    }
+    if ( expC == 0x7FFF ) {
+        if ( sigC.v64 | sigC.v0 ) {
+            uiZ.v64 = 0;
+            uiZ.v0  = 0;
+            goto propagateNaN_ZC;
+        }
+        uiZ.v64 = uiC64;
+        uiZ.v0  = uiC0;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! (sigA.v64 | sigA.v0) ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF128Sig( sigA.v64, sigA.v0 );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! (sigB.v64 | sigB.v0) ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF128Sig( sigB.v64, sigB.v0 );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FFE;
+    sigA.v64 |= UINT64_C( 0x0001000000000000 );
+    sigB.v64 |= UINT64_C( 0x0001000000000000 );
+    sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 8 );
+    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 15 );
+    softfloat_mul128To256M( sigA.v64, sigA.v0, sigB.v64, sigB.v0, sig256Z );
+    sigZ.v64 = sig256Z[indexWord( 4, 3 )];
+    sigZ.v0  = sig256Z[indexWord( 4, 2 )];
+    shiftDist = 0;
+    if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
+        --expZ;
+        shiftDist = -1;
+    }
+    if ( ! expC ) {
+        if ( ! (sigC.v64 | sigC.v0) ) {
+            shiftDist += 8;
+            goto sigZ;
+        }
+        normExpSig = softfloat_normSubnormalF128Sig( sigC.v64, sigC.v0 );
+        expC = normExpSig.exp;
+        sigC = normExpSig.sig;
+    }
+    sigC.v64 |= UINT64_C( 0x0001000000000000 );
+    sigC = softfloat_shortShiftLeft128( sigC.v64, sigC.v0, 8 );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expZ - expC;
+    if ( expDiff < 0 ) {
+        expZ = expC;
+        if ( (signZ == signC) || (expDiff < -1) ) {
+            shiftDist -= expDiff;
+            if ( shiftDist ) {
+                sigZ =
+                    softfloat_shiftRightJam128( sigZ.v64, sigZ.v0, shiftDist );
+            }
+        } else {
+            if ( ! shiftDist ) {
+                x128 =
+                    softfloat_shortShiftRight128(
+                        sig256Z[indexWord( 4, 1 )], sig256Z[indexWord( 4, 0 )],
+                        1
+                    );
+                sig256Z[indexWord( 4, 1 )] = (sigZ.v0<<63) | x128.v64;
+                sig256Z[indexWord( 4, 0 )] = x128.v0;
+                sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, 1 );
+                sig256Z[indexWord( 4, 3 )] = sigZ.v64;
+                sig256Z[indexWord( 4, 2 )] = sigZ.v0;
+            }
+        }
+    } else {
+        if ( shiftDist ) softfloat_add256M( sig256Z, sig256Z, sig256Z );
+        if ( ! expDiff ) {
+            sigZ.v64 = sig256Z[indexWord( 4, 3 )];
+            sigZ.v0  = sig256Z[indexWord( 4, 2 )];
+        } else {
+            sig256C[indexWord( 4, 3 )] = sigC.v64;
+            sig256C[indexWord( 4, 2 )] = sigC.v0;
+            sig256C[indexWord( 4, 1 )] = 0;
+            sig256C[indexWord( 4, 0 )] = 0;
+            softfloat_shiftRightJam256M( sig256C, expDiff, sig256C );
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    shiftDist = 8;
+    if ( signZ == signC ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff <= 0 ) {
+            sigZ = softfloat_add128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );
+        } else {
+            softfloat_add256M( sig256Z, sig256C, sig256Z );
+            sigZ.v64 = sig256Z[indexWord( 4, 3 )];
+            sigZ.v0  = sig256Z[indexWord( 4, 2 )];
+        }
+        if ( sigZ.v64 & UINT64_C( 0x0200000000000000 ) ) {
+            ++expZ;
+            shiftDist = 9;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff < 0 ) {
+            signZ = signC;
+            if ( expDiff < -1 ) {
+                sigZ =
+                    softfloat_sub128( sigC.v64, sigC.v0, sigZ.v64, sigZ.v0 );
+                sigZExtra =
+                    sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];
+                if ( sigZExtra ) {
+                    sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, 0, 1 );
+                }
+                if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
+                    --expZ;
+                    shiftDist = 7;
+                }
+                goto shiftRightRoundPack;
+            } else {
+                sig256C[indexWord( 4, 3 )] = sigC.v64;
+                sig256C[indexWord( 4, 2 )] = sigC.v0;
+                sig256C[indexWord( 4, 1 )] = 0;
+                sig256C[indexWord( 4, 0 )] = 0;
+                softfloat_sub256M( sig256C, sig256Z, sig256Z );
+            }
+        } else if ( ! expDiff ) {
+            sigZ = softfloat_sub128( sigZ.v64, sigZ.v0, sigC.v64, sigC.v0 );
+            if (
+                ! (sigZ.v64 | sigZ.v0) && ! sig256Z[indexWord( 4, 1 )]
+                    && ! sig256Z[indexWord( 4, 0 )]
+            ) {
+                goto completeCancellation;
+            }
+            sig256Z[indexWord( 4, 3 )] = sigZ.v64;
+            sig256Z[indexWord( 4, 2 )] = sigZ.v0;
+            if ( sigZ.v64 & UINT64_C( 0x8000000000000000 ) ) {
+                signZ = ! signZ;
+                softfloat_sub256M( zero256, sig256Z, sig256Z );
+            }
+        } else {
+            softfloat_sub256M( sig256Z, sig256C, sig256Z );
+            if ( 1 < expDiff ) {
+                sigZ.v64 = sig256Z[indexWord( 4, 3 )];
+                sigZ.v0  = sig256Z[indexWord( 4, 2 )];
+                if ( ! (sigZ.v64 & UINT64_C( 0x0100000000000000 )) ) {
+                    --expZ;
+                    shiftDist = 7;
+                }
+                goto sigZ;
+            }
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sigZ.v64  = sig256Z[indexWord( 4, 3 )];
+        sigZ.v0   = sig256Z[indexWord( 4, 2 )];
+        sigZExtra = sig256Z[indexWord( 4, 1 )];
+        sig256Z0  = sig256Z[indexWord( 4, 0 )];
+        if ( sigZ.v64 ) {
+            if ( sig256Z0 ) sigZExtra |= 1;
+        } else {
+            expZ -= 64;
+            sigZ.v64  = sigZ.v0;
+            sigZ.v0   = sigZExtra;
+            sigZExtra = sig256Z0;
+            if ( ! sigZ.v64 ) {
+                expZ -= 64;
+                sigZ.v64  = sigZ.v0;
+                sigZ.v0   = sigZExtra;
+                sigZExtra = 0;
+                if ( ! sigZ.v64 ) {
+                    expZ -= 64;
+                    sigZ.v64 = sigZ.v0;
+                    sigZ.v0  = 0;
+                }
+            }
+        }
+        shiftDist = softfloat_countLeadingZeros64( sigZ.v64 );
+        expZ += 7 - shiftDist;
+        shiftDist = 15 - shiftDist;
+        if ( 0 < shiftDist ) goto shiftRightRoundPack;
+        if ( shiftDist ) {
+            shiftDist = -shiftDist;
+            sigZ = softfloat_shortShiftLeft128( sigZ.v64, sigZ.v0, shiftDist );
+            x128 = softfloat_shortShiftLeft128( 0, sigZExtra, shiftDist );
+            sigZ.v0 |= x128.v64;
+            sigZExtra = x128.v0;
+        }
+        goto roundPack;
+    }
+ sigZ:
+    sigZExtra = sig256Z[indexWord( 4, 1 )] | sig256Z[indexWord( 4, 0 )];
+ shiftRightRoundPack:
+    sigZExtra = (uint64_t) (sigZ.v0<<(64 - shiftDist)) | (sigZExtra != 0);
+    sigZ = softfloat_shortShiftRight128( sigZ.v64, sigZ.v0, shiftDist );
+ roundPack:
+    return
+        softfloat_roundPackToF128(
+            signZ, expZ - 1, sigZ.v64, sigZ.v0, sigZExtra );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN_ABC:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+    goto propagateNaN_ZC;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infProdArg:
+    if ( magBits ) {
+        uiZ.v64 = packToF128UI64( signZ, 0x7FFF, 0 );
+        uiZ.v0 = 0;
+        if ( expC != 0x7FFF ) goto uiZ;
+        if ( sigC.v64 | sigC.v0 ) goto propagateNaN_ZC;
+        if ( signZ == signC ) goto uiZ;
+    }
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ.v64 = defaultNaNF128UI64;
+    uiZ.v0  = defaultNaNF128UI0;
+ propagateNaN_ZC:
+    uiZ = softfloat_propagateNaNF128UI( uiZ.v64, uiZ.v0, uiC64, uiC0 );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    uiZ.v64 = uiC64;
+    uiZ.v0  = uiC0;
+    if ( ! (expC | sigC.v64 | sigC.v0) && (signZ != signC) ) {
+ completeCancellation:
+        uiZ.v64 =
+            packToF128UI64(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+        uiZ.v0 = 0;
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_mulAddF128M.c b/softfloat/source/s_mulAddF128M.c
index f51fc71..3ed3bae 100644
--- a/softfloat/source/s_mulAddF128M.c
+++ b/softfloat/source/s_mulAddF128M.c
@@ -1,382 +1,382 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-void
- softfloat_mulAddF128M(
-     const uint32_t *aWPtr,
-     const uint32_t *bWPtr,
-     const uint32_t *cWPtr,
-     uint32_t *zWPtr,
-     uint_fast8_t op
- )
-{
-    uint32_t uiA96;
-    int32_t expA;
-    uint32_t uiB96;
-    int32_t expB;
-    uint32_t uiC96;
-    bool signC;
-    int32_t expC;
-    bool signProd, prodIsInfinite;
-    uint32_t *ptr, uiZ96, sigA[4];
-    uint_fast8_t shiftDist;
-    uint32_t sigX[5];
-    int32_t expProd;
-    uint32_t sigProd[8], wordSig;
-    bool doSub;
-    uint_fast8_t
-     (*addCarryMRoutinePtr)(
-         uint_fast8_t,
-         const uint32_t *,
-         const uint32_t *,
-         uint_fast8_t,
-         uint32_t *
-     );
-    int32_t expDiff;
-    bool signZ;
-    int32_t expZ;
-    uint32_t *extSigPtr;
-    uint_fast8_t carry;
-    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uiA96 = aWPtr[indexWordHi( 4 )];
-    expA = expF128UI96( uiA96 );
-    uiB96 = bWPtr[indexWordHi( 4 )];
-    expB = expF128UI96( uiB96 );
-    uiC96 = cWPtr[indexWordHi( 4 )];
-    signC = signF128UI96( uiC96 ) ^ (op == softfloat_mulAdd_subC);
-    expC = expF128UI96( uiC96 );
-    signProd =
-        signF128UI96( uiA96 ) ^ signF128UI96( uiB96 )
-            ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    prodIsInfinite = false;
-    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
-        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) {
-            goto propagateNaN_ZC;
-        }
-        ptr = (uint32_t *) aWPtr;
-        if ( ! (uint32_t) (uiA96<<1) ) goto possibleInvalidProd;
-        if ( ! (uint32_t) (uiB96<<1) ) {
-            ptr = (uint32_t *) bWPtr;
-     possibleInvalidProd:
-            if (
-                ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
-                       | ptr[indexWord( 4, 0 )])
-            ) {
-                goto invalid;
-            }
-        }
-        prodIsInfinite = true;
-    }
-    if ( expC == 0x7FFF ) {
-        if (
-            fracF128UI96( uiC96 )
-                || (cWPtr[indexWord( 4, 2 )] | cWPtr[indexWord( 4, 1 )]
-                        | cWPtr[indexWord( 4, 0 )])
-        ) {
-            zWPtr[indexWordHi( 4 )] = 0;
-            goto propagateNaN_ZC;
-        }
-        if ( prodIsInfinite && (signProd != signC) ) goto invalid;
-        goto copyC;
-    }
-    if ( prodIsInfinite ) {
-        uiZ96 = packToF128UI96( signProd, 0x7FFF, 0 );
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA ) {
-        sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000;
-        sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
-        sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
-        sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
-    } else {
-        expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
-        if ( expA == -128 ) goto zeroProd;
-    }
-    if ( expB ) {
-        sigX[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000;
-        sigX[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )];
-        sigX[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )];
-        sigX[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )];
-    } else {
-        expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigX );
-        if ( expB == -128 ) goto zeroProd;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expProd = expA + expB - 0x3FF0;
-    softfloat_mul128MTo256M( sigA, sigX, sigProd );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    wordSig = fracF128UI96( uiC96 );
-    if ( expC ) {
-        --expC;
-        wordSig |= 0x00010000;
-    }
-    sigX[indexWordHi( 5 )] = wordSig;
-    sigX[indexWord( 5, 3 )] = cWPtr[indexWord( 4, 2 )];
-    sigX[indexWord( 5, 2 )] = cWPtr[indexWord( 4, 1 )];
-    sigX[indexWord( 5, 1 )] = cWPtr[indexWord( 4, 0 )];
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    doSub = (signProd != signC);
-    addCarryMRoutinePtr =
-        doSub ? softfloat_addComplCarryM : softfloat_addCarryM;
-    expDiff = expProd - expC;
-    if ( expDiff <= 0 ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signC;
-        expZ = expC;
-        if (
-            sigProd[indexWord( 8, 2 )]
-                || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
-        ) {
-            sigProd[indexWord( 8, 3 )] |= 1;
-        }
-        extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )];
-        if ( expDiff ) {
-            softfloat_shiftRightJam160M( extSigPtr, -expDiff, extSigPtr );
-        }
-        carry = 0;
-        if ( doSub ) {
-            wordSig = extSigPtr[indexWordLo( 5 )];
-            extSigPtr[indexWordLo( 5 )] = -wordSig;
-            carry = ! wordSig;
-        }
-        (*addCarryMRoutinePtr)(
-            4,
-            &sigX[indexMultiwordHi( 5, 4 )],
-            extSigPtr + indexMultiwordHi( 5, 4 ),
-            carry,
-            extSigPtr + indexMultiwordHi( 5, 4 )
-        );
-        wordSig = extSigPtr[indexWordHi( 5 )];
-        if ( ! expZ ) {
-            if ( wordSig & 0x80000000 ) {
-                signZ = ! signZ;
-                softfloat_negX160M( extSigPtr );
-                wordSig = extSigPtr[indexWordHi( 5 )];
-            }
-            goto checkCancellation;
-        }
-        if ( wordSig < 0x00010000 ) {
-            --expZ;
-            softfloat_add160M( extSigPtr, extSigPtr, extSigPtr );
-            goto roundPack;
-        }
-        goto extSigReady_noCancellation;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signProd;
-        expZ = expProd;
-        sigX[indexWordLo( 5 )] = 0;
-        expDiff -= 128;
-        if ( 0 <= expDiff ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            if ( expDiff ) softfloat_shiftRightJam160M( sigX, expDiff, sigX );
-            wordSig = sigX[indexWordLo( 5 )];
-            carry = 0;
-            if ( doSub ) {
-                carry = ! wordSig;
-                wordSig = -wordSig;
-            }
-            carry =
-                (*addCarryMRoutinePtr)(
-                    4,
-                    &sigProd[indexMultiwordLo( 8, 4 )],
-                    &sigX[indexMultiwordHi( 5, 4 )],
-                    carry,
-                    &sigProd[indexMultiwordLo( 8, 4 )]
-                );
-            sigProd[indexWord( 8, 2 )] |= wordSig;
-            ptr = &sigProd[indexWord( 8, 4 )];
-        } else {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            shiftDist = expDiff & 31;
-            if ( shiftDist ) {
-                softfloat_shortShiftRight160M( sigX, shiftDist, sigX );
-            }
-            expDiff >>= 5;
-            extSigPtr =
-                &sigProd[indexMultiwordLo( 8, 5 )] - wordIncr
-                    + expDiff * -wordIncr;
-            carry =
-                (*addCarryMRoutinePtr)( 5, extSigPtr, sigX, doSub, extSigPtr );
-            if ( expDiff == -4 ) {
-                /*------------------------------------------------------------
-                *------------------------------------------------------------*/
-                wordSig = sigProd[indexWordHi( 8 )];
-                if ( wordSig & 0x80000000 ) {
-                    signZ = ! signZ;
-                    softfloat_negX256M( sigProd );
-                    wordSig = sigProd[indexWordHi( 8 )];
-                }
-                /*------------------------------------------------------------
-                *------------------------------------------------------------*/
-                if ( wordSig ) goto expProdBigger_noWordShift;
-                wordSig = sigProd[indexWord( 8, 6 )];
-                if ( 0x00040000 <= wordSig ) goto expProdBigger_noWordShift;
-                expZ -= 32;
-                extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )] - wordIncr;
-                for (;;) {
-                    if ( wordSig ) break;
-                    wordSig = extSigPtr[indexWord( 5, 3 )];
-                    if ( 0x00040000 <= wordSig ) break;
-                    expZ -= 32;
-                    extSigPtr -= wordIncr;
-                    if ( extSigPtr == &sigProd[indexMultiwordLo( 8, 5 )] ) {
-                        goto checkCancellation;
-                    }
-                }
-                /*------------------------------------------------------------
-                *------------------------------------------------------------*/
-                ptr = extSigPtr + indexWordLo( 5 );
-                do {
-                    ptr -= wordIncr;
-                    if ( *ptr ) {
-                        extSigPtr[indexWordLo( 5 )] |= 1;
-                        break;
-                    }
-                } while ( ptr != &sigProd[indexWordLo( 8 )] );
-                wordSig = extSigPtr[indexWordHi( 5 )];
-                goto extSigReady;
-            }
-            ptr = extSigPtr + indexWordHi( 5 ) + wordIncr;
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( carry != doSub ) {
-            if ( doSub ) {
-                do {
-                    wordSig = *ptr;
-                    *ptr = wordSig - 1;
-                    ptr += wordIncr;
-                } while ( ! wordSig );
-            } else {
-                do {
-                    wordSig = *ptr + 1;
-                    *ptr = wordSig;
-                    ptr += wordIncr;
-                } while ( ! wordSig );
-            }
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-     expProdBigger_noWordShift:
-        if (
-            sigProd[indexWord( 8, 2 )]
-                || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
-        ) {
-            sigProd[indexWord( 8, 3 )] |= 1;
-        }
-        extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )];
-        wordSig = extSigPtr[indexWordHi( 5 )];
-    }
- extSigReady:
-    roundPackRoutinePtr = softfloat_normRoundPackMToF128M;
-    if ( wordSig < 0x00010000 ) goto doRoundPack;
- extSigReady_noCancellation:
-    if ( 0x00020000 <= wordSig ) {
-        ++expZ;
-        softfloat_shortShiftRightJam160M( extSigPtr, 1, extSigPtr );
-    }
- roundPack:
-    roundPackRoutinePtr = softfloat_roundPackMToF128M;
- doRoundPack:
-    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_invalidF128M( zWPtr );
- propagateNaN_ZC:
-    softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr );
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    if (
-        ! (uint32_t) (uiC96<<1) && (signProd != signC)
-            && ! cWPtr[indexWord( 4, 2 )]
-            && ! (cWPtr[indexWord( 4, 1 )] | cWPtr[indexWord( 4, 0 )])
-    ) {
-        goto completeCancellation;
-    }
- copyC:
-    zWPtr[indexWordHi( 4 )] = uiC96;
-    zWPtr[indexWord( 4, 2 )] = cWPtr[indexWord( 4, 2 )];
-    zWPtr[indexWord( 4, 1 )] = cWPtr[indexWord( 4, 1 )];
-    zWPtr[indexWord( 4, 0 )] = cWPtr[indexWord( 4, 0 )];
-    return;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- checkCancellation:
-    if (
-        wordSig
-            || (extSigPtr[indexWord( 5, 3 )] | extSigPtr[indexWord( 5, 2 )])
-            || (extSigPtr[indexWord( 5, 1 )] | extSigPtr[indexWord( 5, 0 )])
-    ) {
-        goto extSigReady;
-    }
- completeCancellation:
-    uiZ96 =
-        packToF128UI96(
-            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
- uiZ:
-    zWPtr[indexWordHi( 4 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+void
+ softfloat_mulAddF128M(
+     const uint32_t *aWPtr,
+     const uint32_t *bWPtr,
+     const uint32_t *cWPtr,
+     uint32_t *zWPtr,
+     uint_fast8_t op
+ )
+{
+    uint32_t uiA96;
+    int32_t expA;
+    uint32_t uiB96;
+    int32_t expB;
+    uint32_t uiC96;
+    bool signC;
+    int32_t expC;
+    bool signProd, prodIsInfinite;
+    uint32_t *ptr, uiZ96, sigA[4];
+    uint_fast8_t shiftDist;
+    uint32_t sigX[5];
+    int32_t expProd;
+    uint32_t sigProd[8], wordSig;
+    bool doSub;
+    uint_fast8_t
+     (*addCarryMRoutinePtr)(
+         uint_fast8_t,
+         const uint32_t *,
+         const uint32_t *,
+         uint_fast8_t,
+         uint32_t *
+     );
+    int32_t expDiff;
+    bool signZ;
+    int32_t expZ;
+    uint32_t *extSigPtr;
+    uint_fast8_t carry;
+    void (*roundPackRoutinePtr)( bool, int32_t, uint32_t *, uint32_t * );
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uiA96 = aWPtr[indexWordHi( 4 )];
+    expA = expF128UI96( uiA96 );
+    uiB96 = bWPtr[indexWordHi( 4 )];
+    expB = expF128UI96( uiB96 );
+    uiC96 = cWPtr[indexWordHi( 4 )];
+    signC = signF128UI96( uiC96 ) ^ (op == softfloat_mulAdd_subC);
+    expC = expF128UI96( uiC96 );
+    signProd =
+        signF128UI96( uiA96 ) ^ signF128UI96( uiB96 )
+            ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    prodIsInfinite = false;
+    if ( (expA == 0x7FFF) || (expB == 0x7FFF) ) {
+        if ( softfloat_tryPropagateNaNF128M( aWPtr, bWPtr, zWPtr ) ) {
+            goto propagateNaN_ZC;
+        }
+        ptr = (uint32_t *) aWPtr;
+        if ( ! (uint32_t) (uiA96<<1) ) goto possibleInvalidProd;
+        if ( ! (uint32_t) (uiB96<<1) ) {
+            ptr = (uint32_t *) bWPtr;
+     possibleInvalidProd:
+            if (
+                ! (ptr[indexWord( 4, 2 )] | ptr[indexWord( 4, 1 )]
+                       | ptr[indexWord( 4, 0 )])
+            ) {
+                goto invalid;
+            }
+        }
+        prodIsInfinite = true;
+    }
+    if ( expC == 0x7FFF ) {
+        if (
+            fracF128UI96( uiC96 )
+                || (cWPtr[indexWord( 4, 2 )] | cWPtr[indexWord( 4, 1 )]
+                        | cWPtr[indexWord( 4, 0 )])
+        ) {
+            zWPtr[indexWordHi( 4 )] = 0;
+            goto propagateNaN_ZC;
+        }
+        if ( prodIsInfinite && (signProd != signC) ) goto invalid;
+        goto copyC;
+    }
+    if ( prodIsInfinite ) {
+        uiZ96 = packToF128UI96( signProd, 0x7FFF, 0 );
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA ) {
+        sigA[indexWordHi( 4 )] = fracF128UI96( uiA96 ) | 0x00010000;
+        sigA[indexWord( 4, 2 )] = aWPtr[indexWord( 4, 2 )];
+        sigA[indexWord( 4, 1 )] = aWPtr[indexWord( 4, 1 )];
+        sigA[indexWord( 4, 0 )] = aWPtr[indexWord( 4, 0 )];
+    } else {
+        expA = softfloat_shiftNormSigF128M( aWPtr, 0, sigA );
+        if ( expA == -128 ) goto zeroProd;
+    }
+    if ( expB ) {
+        sigX[indexWordHi( 4 )] = fracF128UI96( uiB96 ) | 0x00010000;
+        sigX[indexWord( 4, 2 )] = bWPtr[indexWord( 4, 2 )];
+        sigX[indexWord( 4, 1 )] = bWPtr[indexWord( 4, 1 )];
+        sigX[indexWord( 4, 0 )] = bWPtr[indexWord( 4, 0 )];
+    } else {
+        expB = softfloat_shiftNormSigF128M( bWPtr, 0, sigX );
+        if ( expB == -128 ) goto zeroProd;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expProd = expA + expB - 0x3FF0;
+    softfloat_mul128MTo256M( sigA, sigX, sigProd );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    wordSig = fracF128UI96( uiC96 );
+    if ( expC ) {
+        --expC;
+        wordSig |= 0x00010000;
+    }
+    sigX[indexWordHi( 5 )] = wordSig;
+    sigX[indexWord( 5, 3 )] = cWPtr[indexWord( 4, 2 )];
+    sigX[indexWord( 5, 2 )] = cWPtr[indexWord( 4, 1 )];
+    sigX[indexWord( 5, 1 )] = cWPtr[indexWord( 4, 0 )];
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    doSub = (signProd != signC);
+    addCarryMRoutinePtr =
+        doSub ? softfloat_addComplCarryM : softfloat_addCarryM;
+    expDiff = expProd - expC;
+    if ( expDiff <= 0 ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signC;
+        expZ = expC;
+        if (
+            sigProd[indexWord( 8, 2 )]
+                || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
+        ) {
+            sigProd[indexWord( 8, 3 )] |= 1;
+        }
+        extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )];
+        if ( expDiff ) {
+            softfloat_shiftRightJam160M( extSigPtr, -expDiff, extSigPtr );
+        }
+        carry = 0;
+        if ( doSub ) {
+            wordSig = extSigPtr[indexWordLo( 5 )];
+            extSigPtr[indexWordLo( 5 )] = -wordSig;
+            carry = ! wordSig;
+        }
+        (*addCarryMRoutinePtr)(
+            4,
+            &sigX[indexMultiwordHi( 5, 4 )],
+            extSigPtr + indexMultiwordHi( 5, 4 ),
+            carry,
+            extSigPtr + indexMultiwordHi( 5, 4 )
+        );
+        wordSig = extSigPtr[indexWordHi( 5 )];
+        if ( ! expZ ) {
+            if ( wordSig & 0x80000000 ) {
+                signZ = ! signZ;
+                softfloat_negX160M( extSigPtr );
+                wordSig = extSigPtr[indexWordHi( 5 )];
+            }
+            goto checkCancellation;
+        }
+        if ( wordSig < 0x00010000 ) {
+            --expZ;
+            softfloat_add160M( extSigPtr, extSigPtr, extSigPtr );
+            goto roundPack;
+        }
+        goto extSigReady_noCancellation;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signProd;
+        expZ = expProd;
+        sigX[indexWordLo( 5 )] = 0;
+        expDiff -= 128;
+        if ( 0 <= expDiff ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            if ( expDiff ) softfloat_shiftRightJam160M( sigX, expDiff, sigX );
+            wordSig = sigX[indexWordLo( 5 )];
+            carry = 0;
+            if ( doSub ) {
+                carry = ! wordSig;
+                wordSig = -wordSig;
+            }
+            carry =
+                (*addCarryMRoutinePtr)(
+                    4,
+                    &sigProd[indexMultiwordLo( 8, 4 )],
+                    &sigX[indexMultiwordHi( 5, 4 )],
+                    carry,
+                    &sigProd[indexMultiwordLo( 8, 4 )]
+                );
+            sigProd[indexWord( 8, 2 )] |= wordSig;
+            ptr = &sigProd[indexWord( 8, 4 )];
+        } else {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            shiftDist = expDiff & 31;
+            if ( shiftDist ) {
+                softfloat_shortShiftRight160M( sigX, shiftDist, sigX );
+            }
+            expDiff >>= 5;
+            extSigPtr =
+                &sigProd[indexMultiwordLo( 8, 5 )] - wordIncr
+                    + expDiff * -wordIncr;
+            carry =
+                (*addCarryMRoutinePtr)( 5, extSigPtr, sigX, doSub, extSigPtr );
+            if ( expDiff == -4 ) {
+                /*------------------------------------------------------------
+                *------------------------------------------------------------*/
+                wordSig = sigProd[indexWordHi( 8 )];
+                if ( wordSig & 0x80000000 ) {
+                    signZ = ! signZ;
+                    softfloat_negX256M( sigProd );
+                    wordSig = sigProd[indexWordHi( 8 )];
+                }
+                /*------------------------------------------------------------
+                *------------------------------------------------------------*/
+                if ( wordSig ) goto expProdBigger_noWordShift;
+                wordSig = sigProd[indexWord( 8, 6 )];
+                if ( 0x00040000 <= wordSig ) goto expProdBigger_noWordShift;
+                expZ -= 32;
+                extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )] - wordIncr;
+                for (;;) {
+                    if ( wordSig ) break;
+                    wordSig = extSigPtr[indexWord( 5, 3 )];
+                    if ( 0x00040000 <= wordSig ) break;
+                    expZ -= 32;
+                    extSigPtr -= wordIncr;
+                    if ( extSigPtr == &sigProd[indexMultiwordLo( 8, 5 )] ) {
+                        goto checkCancellation;
+                    }
+                }
+                /*------------------------------------------------------------
+                *------------------------------------------------------------*/
+                ptr = extSigPtr + indexWordLo( 5 );
+                do {
+                    ptr -= wordIncr;
+                    if ( *ptr ) {
+                        extSigPtr[indexWordLo( 5 )] |= 1;
+                        break;
+                    }
+                } while ( ptr != &sigProd[indexWordLo( 8 )] );
+                wordSig = extSigPtr[indexWordHi( 5 )];
+                goto extSigReady;
+            }
+            ptr = extSigPtr + indexWordHi( 5 ) + wordIncr;
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( carry != doSub ) {
+            if ( doSub ) {
+                do {
+                    wordSig = *ptr;
+                    *ptr = wordSig - 1;
+                    ptr += wordIncr;
+                } while ( ! wordSig );
+            } else {
+                do {
+                    wordSig = *ptr + 1;
+                    *ptr = wordSig;
+                    ptr += wordIncr;
+                } while ( ! wordSig );
+            }
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+     expProdBigger_noWordShift:
+        if (
+            sigProd[indexWord( 8, 2 )]
+                || (sigProd[indexWord( 8, 1 )] | sigProd[indexWord( 8, 0 )])
+        ) {
+            sigProd[indexWord( 8, 3 )] |= 1;
+        }
+        extSigPtr = &sigProd[indexMultiwordHi( 8, 5 )];
+        wordSig = extSigPtr[indexWordHi( 5 )];
+    }
+ extSigReady:
+    roundPackRoutinePtr = softfloat_normRoundPackMToF128M;
+    if ( wordSig < 0x00010000 ) goto doRoundPack;
+ extSigReady_noCancellation:
+    if ( 0x00020000 <= wordSig ) {
+        ++expZ;
+        softfloat_shortShiftRightJam160M( extSigPtr, 1, extSigPtr );
+    }
+ roundPack:
+    roundPackRoutinePtr = softfloat_roundPackMToF128M;
+ doRoundPack:
+    (*roundPackRoutinePtr)( signZ, expZ, extSigPtr, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_invalidF128M( zWPtr );
+ propagateNaN_ZC:
+    softfloat_propagateNaNF128M( zWPtr, cWPtr, zWPtr );
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    if (
+        ! (uint32_t) (uiC96<<1) && (signProd != signC)
+            && ! cWPtr[indexWord( 4, 2 )]
+            && ! (cWPtr[indexWord( 4, 1 )] | cWPtr[indexWord( 4, 0 )])
+    ) {
+        goto completeCancellation;
+    }
+ copyC:
+    zWPtr[indexWordHi( 4 )] = uiC96;
+    zWPtr[indexWord( 4, 2 )] = cWPtr[indexWord( 4, 2 )];
+    zWPtr[indexWord( 4, 1 )] = cWPtr[indexWord( 4, 1 )];
+    zWPtr[indexWord( 4, 0 )] = cWPtr[indexWord( 4, 0 )];
+    return;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ checkCancellation:
+    if (
+        wordSig
+            || (extSigPtr[indexWord( 5, 3 )] | extSigPtr[indexWord( 5, 2 )])
+            || (extSigPtr[indexWord( 5, 1 )] | extSigPtr[indexWord( 5, 0 )])
+    ) {
+        goto extSigReady;
+    }
+ completeCancellation:
+    uiZ96 =
+        packToF128UI96(
+            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+ uiZ:
+    zWPtr[indexWordHi( 4 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
diff --git a/softfloat/source/s_mulAddF16.c b/softfloat/source/s_mulAddF16.c
index 3a684ac..cca4db4 100644
--- a/softfloat/source/s_mulAddF16.c
+++ b/softfloat/source/s_mulAddF16.c
@@ -1,226 +1,226 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t
- softfloat_mulAddF16(
-     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )
-{
-    bool signA;
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    bool signB;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    bool signC;
-    int_fast8_t expC;
-    uint_fast16_t sigC;
-    bool signProd;
-    uint_fast16_t magBits, uiZ;
-    struct exp8_sig16 normExpSig;
-    int_fast8_t expProd;
-    uint_fast32_t sigProd;
-    bool signZ;
-    int_fast8_t expZ;
-    uint_fast16_t sigZ;
-    int_fast8_t expDiff;
-    uint_fast32_t sig32Z, sig32C;
-    int_fast8_t shiftDist;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signF16UI( uiA );
-    expA  = expF16UI( uiA );
-    sigA  = fracF16UI( uiA );
-    signB = signF16UI( uiB );
-    expB  = expF16UI( uiB );
-    sigB  = fracF16UI( uiB );
-    signC = signF16UI( uiC ) ^ (op == softfloat_mulAdd_subC);
-    expC  = expF16UI( uiC );
-    sigC  = fracF16UI( uiC );
-    signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x1F ) {
-        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN_ABC;
-        magBits = expB | sigB;
-        goto infProdArg;
-    }
-    if ( expB == 0x1F ) {
-        if ( sigB ) goto propagateNaN_ABC;
-        magBits = expA | sigA;
-        goto infProdArg;
-    }
-    if ( expC == 0x1F ) {
-        if ( sigC ) {
-            uiZ = 0;
-            goto propagateNaN_ZC;
-        }
-        uiZ = uiC;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF16Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF16Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expProd = expA + expB - 0xE;
-    sigA = (sigA | 0x0400)<<4;
-    sigB = (sigB | 0x0400)<<4;
-    sigProd = (uint_fast32_t) sigA * sigB;
-    if ( sigProd < 0x20000000 ) {
-        --expProd;
-        sigProd <<= 1;
-    }
-    signZ = signProd;
-    if ( ! expC ) {
-        if ( ! sigC ) {
-            expZ = expProd - 1;
-            sigZ = sigProd>>15 | ((sigProd & 0x7FFF) != 0);
-            goto roundPack;
-        }
-        normExpSig = softfloat_normSubnormalF16Sig( sigC );
-        expC = normExpSig.exp;
-        sigC = normExpSig.sig;
-    }
-    sigC = (sigC | 0x0400)<<3;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expProd - expC;
-    if ( signProd == signC ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff <= 0 ) {
-            expZ = expC;
-            sigZ = sigC + softfloat_shiftRightJam32( sigProd, 16 - expDiff );
-        } else {
-            expZ = expProd;
-            sig32Z =
-                sigProd
-                    + softfloat_shiftRightJam32(
-                          (uint_fast32_t) sigC<<16, expDiff );
-            sigZ = sig32Z>>16 | ((sig32Z & 0xFFFF) != 0 );
-        }
-        if ( sigZ < 0x4000 ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig32C = (uint_fast32_t) sigC<<16;
-        if ( expDiff < 0 ) {
-            signZ = signC;
-            expZ = expC;
-            sig32Z = sig32C - softfloat_shiftRightJam32( sigProd, -expDiff );
-        } else if ( ! expDiff ) {
-            expZ = expProd;
-            sig32Z = sigProd - sig32C;
-            if ( ! sig32Z ) goto completeCancellation;
-            if ( sig32Z & 0x80000000 ) {
-                signZ = ! signZ;
-                sig32Z = -sig32Z;
-            }
-        } else {
-            expZ = expProd;
-            sig32Z = sigProd - softfloat_shiftRightJam32( sig32C, expDiff );
-        }
-        shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1;
-        expZ -= shiftDist;
-        shiftDist -= 16;
-        if ( shiftDist < 0 ) {
-            sigZ =
-                sig32Z>>(-shiftDist)
-                    | ((uint32_t) (sig32Z<<(shiftDist & 31)) != 0);
-        } else {
-            sigZ = (uint_fast16_t) sig32Z<<shiftDist;
-        }
-    }
- roundPack:
-    return softfloat_roundPackToF16( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto propagateNaN_ZC;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infProdArg:
-    if ( magBits ) {
-        uiZ = packToF16UI( signProd, 0x1F, 0 );
-        if ( expC != 0x1F ) goto uiZ;
-        if ( sigC ) goto propagateNaN_ZC;
-        if ( signProd == signC ) goto uiZ;
-    }
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF16UI;
- propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    uiZ = uiC;
-    if ( ! (expC | sigC) && (signProd != signC) ) {
- completeCancellation:
-        uiZ =
-            packToF16UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t
+ softfloat_mulAddF16(
+     uint_fast16_t uiA, uint_fast16_t uiB, uint_fast16_t uiC, uint_fast8_t op )
+{
+    bool signA;
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    bool signB;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    bool signC;
+    int_fast8_t expC;
+    uint_fast16_t sigC;
+    bool signProd;
+    uint_fast16_t magBits, uiZ;
+    struct exp8_sig16 normExpSig;
+    int_fast8_t expProd;
+    uint_fast32_t sigProd;
+    bool signZ;
+    int_fast8_t expZ;
+    uint_fast16_t sigZ;
+    int_fast8_t expDiff;
+    uint_fast32_t sig32Z, sig32C;
+    int_fast8_t shiftDist;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signF16UI( uiA );
+    expA  = expF16UI( uiA );
+    sigA  = fracF16UI( uiA );
+    signB = signF16UI( uiB );
+    expB  = expF16UI( uiB );
+    sigB  = fracF16UI( uiB );
+    signC = signF16UI( uiC ) ^ (op == softfloat_mulAdd_subC);
+    expC  = expF16UI( uiC );
+    sigC  = fracF16UI( uiC );
+    signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x1F ) {
+        if ( sigA || ((expB == 0x1F) && sigB) ) goto propagateNaN_ABC;
+        magBits = expB | sigB;
+        goto infProdArg;
+    }
+    if ( expB == 0x1F ) {
+        if ( sigB ) goto propagateNaN_ABC;
+        magBits = expA | sigA;
+        goto infProdArg;
+    }
+    if ( expC == 0x1F ) {
+        if ( sigC ) {
+            uiZ = 0;
+            goto propagateNaN_ZC;
+        }
+        uiZ = uiC;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF16Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF16Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expProd = expA + expB - 0xE;
+    sigA = (sigA | 0x0400)<<4;
+    sigB = (sigB | 0x0400)<<4;
+    sigProd = (uint_fast32_t) sigA * sigB;
+    if ( sigProd < 0x20000000 ) {
+        --expProd;
+        sigProd <<= 1;
+    }
+    signZ = signProd;
+    if ( ! expC ) {
+        if ( ! sigC ) {
+            expZ = expProd - 1;
+            sigZ = sigProd>>15 | ((sigProd & 0x7FFF) != 0);
+            goto roundPack;
+        }
+        normExpSig = softfloat_normSubnormalF16Sig( sigC );
+        expC = normExpSig.exp;
+        sigC = normExpSig.sig;
+    }
+    sigC = (sigC | 0x0400)<<3;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expProd - expC;
+    if ( signProd == signC ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff <= 0 ) {
+            expZ = expC;
+            sigZ = sigC + softfloat_shiftRightJam32( sigProd, 16 - expDiff );
+        } else {
+            expZ = expProd;
+            sig32Z =
+                sigProd
+                    + softfloat_shiftRightJam32(
+                          (uint_fast32_t) sigC<<16, expDiff );
+            sigZ = sig32Z>>16 | ((sig32Z & 0xFFFF) != 0 );
+        }
+        if ( sigZ < 0x4000 ) {
+            --expZ;
+            sigZ <<= 1;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig32C = (uint_fast32_t) sigC<<16;
+        if ( expDiff < 0 ) {
+            signZ = signC;
+            expZ = expC;
+            sig32Z = sig32C - softfloat_shiftRightJam32( sigProd, -expDiff );
+        } else if ( ! expDiff ) {
+            expZ = expProd;
+            sig32Z = sigProd - sig32C;
+            if ( ! sig32Z ) goto completeCancellation;
+            if ( sig32Z & 0x80000000 ) {
+                signZ = ! signZ;
+                sig32Z = -sig32Z;
+            }
+        } else {
+            expZ = expProd;
+            sig32Z = sigProd - softfloat_shiftRightJam32( sig32C, expDiff );
+        }
+        shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1;
+        expZ -= shiftDist;
+        shiftDist -= 16;
+        if ( shiftDist < 0 ) {
+            sigZ =
+                sig32Z>>(-shiftDist)
+                    | ((uint32_t) (sig32Z<<(shiftDist & 31)) != 0);
+        } else {
+            sigZ = (uint_fast16_t) sig32Z<<shiftDist;
+        }
+    }
+ roundPack:
+    return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN_ABC:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto propagateNaN_ZC;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infProdArg:
+    if ( magBits ) {
+        uiZ = packToF16UI( signProd, 0x1F, 0 );
+        if ( expC != 0x1F ) goto uiZ;
+        if ( sigC ) goto propagateNaN_ZC;
+        if ( signProd == signC ) goto uiZ;
+    }
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF16UI;
+ propagateNaN_ZC:
+    uiZ = softfloat_propagateNaNF16UI( uiZ, uiC );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    uiZ = uiC;
+    if ( ! (expC | sigC) && (signProd != signC) ) {
+ completeCancellation:
+        uiZ =
+            packToF16UI(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_mulAddF32.c b/softfloat/source/s_mulAddF32.c
index 6cdd9fd..805517c 100644
--- a/softfloat/source/s_mulAddF32.c
+++ b/softfloat/source/s_mulAddF32.c
@@ -1,224 +1,224 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t
- softfloat_mulAddF32(
-     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )
-{
-    bool signA;
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    bool signC;
-    int_fast16_t expC;
-    uint_fast32_t sigC;
-    bool signProd;
-    uint_fast32_t magBits, uiZ;
-    struct exp16_sig32 normExpSig;
-    int_fast16_t expProd;
-    uint_fast64_t sigProd;
-    bool signZ;
-    int_fast16_t expZ;
-    uint_fast32_t sigZ;
-    int_fast16_t expDiff;
-    uint_fast64_t sig64Z, sig64C;
-    int_fast8_t shiftDist;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signF32UI( uiA );
-    expA  = expF32UI( uiA );
-    sigA  = fracF32UI( uiA );
-    signB = signF32UI( uiB );
-    expB  = expF32UI( uiB );
-    sigB  = fracF32UI( uiB );
-    signC = signF32UI( uiC ) ^ (op == softfloat_mulAdd_subC);
-    expC  = expF32UI( uiC );
-    sigC  = fracF32UI( uiC );
-    signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0xFF ) {
-        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN_ABC;
-        magBits = expB | sigB;
-        goto infProdArg;
-    }
-    if ( expB == 0xFF ) {
-        if ( sigB ) goto propagateNaN_ABC;
-        magBits = expA | sigA;
-        goto infProdArg;
-    }
-    if ( expC == 0xFF ) {
-        if ( sigC ) {
-            uiZ = 0;
-            goto propagateNaN_ZC;
-        }
-        uiZ = uiC;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF32Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF32Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expProd = expA + expB - 0x7E;
-    sigA = (sigA | 0x00800000)<<7;
-    sigB = (sigB | 0x00800000)<<7;
-    sigProd = (uint_fast64_t) sigA * sigB;
-    if ( sigProd < UINT64_C( 0x2000000000000000 ) ) {
-        --expProd;
-        sigProd <<= 1;
-    }
-    signZ = signProd;
-    if ( ! expC ) {
-        if ( ! sigC ) {
-            expZ = expProd - 1;
-            sigZ = softfloat_shortShiftRightJam64( sigProd, 31 );
-            goto roundPack;
-        }
-        normExpSig = softfloat_normSubnormalF32Sig( sigC );
-        expC = normExpSig.exp;
-        sigC = normExpSig.sig;
-    }
-    sigC = (sigC | 0x00800000)<<6;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expProd - expC;
-    if ( signProd == signC ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff <= 0 ) {
-            expZ = expC;
-            sigZ = sigC + softfloat_shiftRightJam64( sigProd, 32 - expDiff );
-        } else {
-            expZ = expProd;
-            sig64Z =
-                sigProd
-                    + softfloat_shiftRightJam64(
-                          (uint_fast64_t) sigC<<32, expDiff );
-            sigZ = softfloat_shortShiftRightJam64( sig64Z, 32 );
-        }
-        if ( sigZ < 0x40000000 ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sig64C = (uint_fast64_t) sigC<<32;
-        if ( expDiff < 0 ) {
-            signZ = signC;
-            expZ = expC;
-            sig64Z = sig64C - softfloat_shiftRightJam64( sigProd, -expDiff );
-        } else if ( ! expDiff ) {
-            expZ = expProd;
-            sig64Z = sigProd - sig64C;
-            if ( ! sig64Z ) goto completeCancellation;
-            if ( sig64Z & UINT64_C( 0x8000000000000000 ) ) {
-                signZ = ! signZ;
-                sig64Z = -sig64Z;
-            }
-        } else {
-            expZ = expProd;
-            sig64Z = sigProd - softfloat_shiftRightJam64( sig64C, expDiff );
-        }
-        shiftDist = softfloat_countLeadingZeros64( sig64Z ) - 1;
-        expZ -= shiftDist;
-        shiftDist -= 32;
-        if ( shiftDist < 0 ) {
-            sigZ = softfloat_shortShiftRightJam64( sig64Z, -shiftDist );
-        } else {
-            sigZ = (uint_fast32_t) sig64Z<<shiftDist;
-        }
-    }
- roundPack:
-    return softfloat_roundPackToF32( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
-    goto propagateNaN_ZC;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infProdArg:
-    if ( magBits ) {
-        uiZ = packToF32UI( signProd, 0xFF, 0 );
-        if ( expC != 0xFF ) goto uiZ;
-        if ( sigC ) goto propagateNaN_ZC;
-        if ( signProd == signC ) goto uiZ;
-    }
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF32UI;
- propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    uiZ = uiC;
-    if ( ! (expC | sigC) && (signProd != signC) ) {
- completeCancellation:
-        uiZ =
-            packToF32UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t
+ softfloat_mulAddF32(
+     uint_fast32_t uiA, uint_fast32_t uiB, uint_fast32_t uiC, uint_fast8_t op )
+{
+    bool signA;
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    bool signC;
+    int_fast16_t expC;
+    uint_fast32_t sigC;
+    bool signProd;
+    uint_fast32_t magBits, uiZ;
+    struct exp16_sig32 normExpSig;
+    int_fast16_t expProd;
+    uint_fast64_t sigProd;
+    bool signZ;
+    int_fast16_t expZ;
+    uint_fast32_t sigZ;
+    int_fast16_t expDiff;
+    uint_fast64_t sig64Z, sig64C;
+    int_fast8_t shiftDist;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signF32UI( uiA );
+    expA  = expF32UI( uiA );
+    sigA  = fracF32UI( uiA );
+    signB = signF32UI( uiB );
+    expB  = expF32UI( uiB );
+    sigB  = fracF32UI( uiB );
+    signC = signF32UI( uiC ) ^ (op == softfloat_mulAdd_subC);
+    expC  = expF32UI( uiC );
+    sigC  = fracF32UI( uiC );
+    signProd = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0xFF ) {
+        if ( sigA || ((expB == 0xFF) && sigB) ) goto propagateNaN_ABC;
+        magBits = expB | sigB;
+        goto infProdArg;
+    }
+    if ( expB == 0xFF ) {
+        if ( sigB ) goto propagateNaN_ABC;
+        magBits = expA | sigA;
+        goto infProdArg;
+    }
+    if ( expC == 0xFF ) {
+        if ( sigC ) {
+            uiZ = 0;
+            goto propagateNaN_ZC;
+        }
+        uiZ = uiC;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF32Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF32Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expProd = expA + expB - 0x7E;
+    sigA = (sigA | 0x00800000)<<7;
+    sigB = (sigB | 0x00800000)<<7;
+    sigProd = (uint_fast64_t) sigA * sigB;
+    if ( sigProd < UINT64_C( 0x2000000000000000 ) ) {
+        --expProd;
+        sigProd <<= 1;
+    }
+    signZ = signProd;
+    if ( ! expC ) {
+        if ( ! sigC ) {
+            expZ = expProd - 1;
+            sigZ = softfloat_shortShiftRightJam64( sigProd, 31 );
+            goto roundPack;
+        }
+        normExpSig = softfloat_normSubnormalF32Sig( sigC );
+        expC = normExpSig.exp;
+        sigC = normExpSig.sig;
+    }
+    sigC = (sigC | 0x00800000)<<6;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expProd - expC;
+    if ( signProd == signC ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff <= 0 ) {
+            expZ = expC;
+            sigZ = sigC + softfloat_shiftRightJam64( sigProd, 32 - expDiff );
+        } else {
+            expZ = expProd;
+            sig64Z =
+                sigProd
+                    + softfloat_shiftRightJam64(
+                          (uint_fast64_t) sigC<<32, expDiff );
+            sigZ = softfloat_shortShiftRightJam64( sig64Z, 32 );
+        }
+        if ( sigZ < 0x40000000 ) {
+            --expZ;
+            sigZ <<= 1;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sig64C = (uint_fast64_t) sigC<<32;
+        if ( expDiff < 0 ) {
+            signZ = signC;
+            expZ = expC;
+            sig64Z = sig64C - softfloat_shiftRightJam64( sigProd, -expDiff );
+        } else if ( ! expDiff ) {
+            expZ = expProd;
+            sig64Z = sigProd - sig64C;
+            if ( ! sig64Z ) goto completeCancellation;
+            if ( sig64Z & UINT64_C( 0x8000000000000000 ) ) {
+                signZ = ! signZ;
+                sig64Z = -sig64Z;
+            }
+        } else {
+            expZ = expProd;
+            sig64Z = sigProd - softfloat_shiftRightJam64( sig64C, expDiff );
+        }
+        shiftDist = softfloat_countLeadingZeros64( sig64Z ) - 1;
+        expZ -= shiftDist;
+        shiftDist -= 32;
+        if ( shiftDist < 0 ) {
+            sigZ = softfloat_shortShiftRightJam64( sig64Z, -shiftDist );
+        } else {
+            sigZ = (uint_fast32_t) sig64Z<<shiftDist;
+        }
+    }
+ roundPack:
+    return softfloat_roundPackToF32( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN_ABC:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+    goto propagateNaN_ZC;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infProdArg:
+    if ( magBits ) {
+        uiZ = packToF32UI( signProd, 0xFF, 0 );
+        if ( expC != 0xFF ) goto uiZ;
+        if ( sigC ) goto propagateNaN_ZC;
+        if ( signProd == signC ) goto uiZ;
+    }
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF32UI;
+ propagateNaN_ZC:
+    uiZ = softfloat_propagateNaNF32UI( uiZ, uiC );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    uiZ = uiC;
+    if ( ! (expC | sigC) && (signProd != signC) ) {
+ completeCancellation:
+        uiZ =
+            packToF32UI(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_mulAddF64.c b/softfloat/source/s_mulAddF64.c
index b8bb4c4..cc1df45 100644
--- a/softfloat/source/s_mulAddF64.c
+++ b/softfloat/source/s_mulAddF64.c
@@ -1,496 +1,496 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-float64_t
- softfloat_mulAddF64(
-     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
-{
-    bool signA;
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    bool signB;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    bool signC;
-    int_fast16_t expC;
-    uint_fast64_t sigC;
-    bool signZ;
-    uint_fast64_t magBits, uiZ;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-    struct uint128 sig128Z;
-    uint_fast64_t sigZ;
-    int_fast16_t expDiff;
-    struct uint128 sig128C;
-    int_fast8_t shiftDist;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    signB = signF64UI( uiB );
-    expB  = expF64UI( uiB );
-    sigB  = fracF64UI( uiB );
-    signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);
-    expC  = expF64UI( uiC );
-    sigC  = fracF64UI( uiC );
-    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;
-        magBits = expB | sigB;
-        goto infProdArg;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN_ABC;
-        magBits = expA | sigA;
-        goto infProdArg;
-    }
-    if ( expC == 0x7FF ) {
-        if ( sigC ) {
-            uiZ = 0;
-            goto propagateNaN_ZC;
-        }
-        uiZ = uiC;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FE;
-    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
-    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<10;
-    sig128Z = softfloat_mul64To128( sigA, sigB );
-    if ( sig128Z.v64 < UINT64_C( 0x2000000000000000 ) ) {
-        --expZ;
-        sig128Z =
-            softfloat_add128(
-                sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );
-    }
-    if ( ! expC ) {
-        if ( ! sigC ) {
-            --expZ;
-            sigZ = sig128Z.v64<<1 | (sig128Z.v0 != 0);
-            goto roundPack;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( sigC );
-        expC = normExpSig.exp;
-        sigC = normExpSig.sig;
-    }
-    sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<9;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expZ - expC;
-    if ( expDiff < 0 ) {
-        expZ = expC;
-        if ( (signZ == signC) || (expDiff < -1) ) {
-            sig128Z.v64 = softfloat_shiftRightJam64( sig128Z.v64, -expDiff );
-        } else {
-            sig128Z =
-                softfloat_shortShiftRightJam128( sig128Z.v64, sig128Z.v0, 1 );
-        }
-    } else if ( expDiff ) {
-        sig128C = softfloat_shiftRightJam128( sigC, 0, expDiff );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signZ == signC ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff <= 0 ) {
-            sigZ = (sigC + sig128Z.v64) | (sig128Z.v0 != 0);
-        } else {
-            sig128Z =
-                softfloat_add128(
-                    sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );
-            sigZ = sig128Z.v64 | (sig128Z.v0 != 0);
-        }
-        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
-            --expZ;
-            sigZ <<= 1;
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff < 0 ) {
-            signZ = signC;
-            sig128Z = softfloat_sub128( sigC, 0, sig128Z.v64, sig128Z.v0 );
-        } else if ( ! expDiff ) {
-            sig128Z.v64 = sig128Z.v64 - sigC;
-            if ( ! (sig128Z.v64 | sig128Z.v0) ) goto completeCancellation;
-            if ( sig128Z.v64 & UINT64_C( 0x8000000000000000 ) ) {
-                signZ = ! signZ;
-                sig128Z = softfloat_sub128( 0, 0, sig128Z.v64, sig128Z.v0 );
-            }
-        } else {
-            sig128Z =
-                softfloat_sub128(
-                    sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( ! sig128Z.v64 ) {
-            expZ -= 64;
-            sig128Z.v64 = sig128Z.v0;
-            sig128Z.v0 = 0;
-        }
-        shiftDist = softfloat_countLeadingZeros64( sig128Z.v64 ) - 1;
-        expZ -= shiftDist;
-        if ( shiftDist < 0 ) {
-            sigZ = softfloat_shortShiftRightJam64( sig128Z.v64, -shiftDist );
-        } else {
-            sig128Z =
-                softfloat_shortShiftLeft128(
-                    sig128Z.v64, sig128Z.v0, shiftDist );
-            sigZ = sig128Z.v64;
-        }
-        sigZ |= (sig128Z.v0 != 0);
-    }
- roundPack:
-    return softfloat_roundPackToF64( signZ, expZ, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto propagateNaN_ZC;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infProdArg:
-    if ( magBits ) {
-        uiZ = packToF64UI( signZ, 0x7FF, 0 );
-        if ( expC != 0x7FF ) goto uiZ;
-        if ( sigC ) goto propagateNaN_ZC;
-        if ( signZ == signC ) goto uiZ;
-    }
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
- propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    uiZ = uiC;
-    if ( ! (expC | sigC) && (signZ != signC) ) {
- completeCancellation:
-        uiZ =
-            packToF64UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#else
-
-float64_t
- softfloat_mulAddF64(
-     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
-{
-    bool signA;
-    int_fast16_t expA;
-    uint64_t sigA;
-    bool signB;
-    int_fast16_t expB;
-    uint64_t sigB;
-    bool signC;
-    int_fast16_t expC;
-    uint64_t sigC;
-    bool signZ;
-    uint64_t magBits, uiZ;
-    struct exp16_sig64 normExpSig;
-    int_fast16_t expZ;
-    uint32_t sig128Z[4];
-    uint64_t sigZ;
-    int_fast16_t shiftDist, expDiff;
-    uint32_t sig128C[4];
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    signA = signF64UI( uiA );
-    expA  = expF64UI( uiA );
-    sigA  = fracF64UI( uiA );
-    signB = signF64UI( uiB );
-    expB  = expF64UI( uiB );
-    sigB  = fracF64UI( uiB );
-    signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);
-    expC  = expF64UI( uiC );
-    sigC  = fracF64UI( uiC );
-    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( expA == 0x7FF ) {
-        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;
-        magBits = expB | sigB;
-        goto infProdArg;
-    }
-    if ( expB == 0x7FF ) {
-        if ( sigB ) goto propagateNaN_ABC;
-        magBits = expA | sigA;
-        goto infProdArg;
-    }
-    if ( expC == 0x7FF ) {
-        if ( sigC ) {
-            uiZ = 0;
-            goto propagateNaN_ZC;
-        }
-        uiZ = uiC;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( ! expA ) {
-        if ( ! sigA ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF64Sig( sigA );
-        expA = normExpSig.exp;
-        sigA = normExpSig.sig;
-    }
-    if ( ! expB ) {
-        if ( ! sigB ) goto zeroProd;
-        normExpSig = softfloat_normSubnormalF64Sig( sigB );
-        expB = normExpSig.exp;
-        sigB = normExpSig.sig;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA + expB - 0x3FE;
-    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
-    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;
-    softfloat_mul64To128M( sigA, sigB, sig128Z );
-    sigZ =
-        (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )];
-    shiftDist = 0;
-    if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
-        --expZ;
-        shiftDist = -1;
-    }
-    if ( ! expC ) {
-        if ( ! sigC ) {
-            if ( shiftDist ) sigZ <<= 1;
-            goto sigZ;
-        }
-        normExpSig = softfloat_normSubnormalF64Sig( sigC );
-        expC = normExpSig.exp;
-        sigC = normExpSig.sig;
-    }
-    sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<10;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expZ - expC;
-    if ( expDiff < 0 ) {
-        expZ = expC;
-        if ( (signZ == signC) || (expDiff < -1) ) {
-            shiftDist -= expDiff;
-            if ( shiftDist) {
-                sigZ = softfloat_shiftRightJam64( sigZ, shiftDist );
-            }
-        } else {
-            if ( ! shiftDist ) {
-                softfloat_shortShiftRight128M( sig128Z, 1, sig128Z );
-            }
-        }
-    } else {
-        if ( shiftDist ) softfloat_add128M( sig128Z, sig128Z, sig128Z );
-        if ( ! expDiff ) {
-            sigZ =
-                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
-                    | sig128Z[indexWord( 4, 2 )];
-        } else {
-            sig128C[indexWord( 4, 3 )] = sigC>>32;
-            sig128C[indexWord( 4, 2 )] = sigC;
-            sig128C[indexWord( 4, 1 )] = 0;
-            sig128C[indexWord( 4, 0 )] = 0;
-            softfloat_shiftRightJam128M( sig128C, expDiff, sig128C );
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( signZ == signC ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff <= 0 ) {
-            sigZ += sigC;
-        } else {
-            softfloat_add128M( sig128Z, sig128C, sig128Z );
-            sigZ =
-                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
-                    | sig128Z[indexWord( 4, 2 )];
-        }
-        if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {
-            ++expZ;
-            sigZ = softfloat_shortShiftRightJam64( sigZ, 1 );
-        }
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expDiff < 0 ) {
-            signZ = signC;
-            if ( expDiff < -1 ) {
-                sigZ = sigC - sigZ;
-                if (
-                    sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )]
-                ) {
-                    sigZ = (sigZ - 1) | 1;
-                }
-                if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
-                    --expZ;
-                    sigZ <<= 1;
-                }
-                goto roundPack;
-            } else {
-                sig128C[indexWord( 4, 3 )] = sigC>>32;
-                sig128C[indexWord( 4, 2 )] = sigC;
-                sig128C[indexWord( 4, 1 )] = 0;
-                sig128C[indexWord( 4, 0 )] = 0;
-                softfloat_sub128M( sig128C, sig128Z, sig128Z );
-            }
-        } else if ( ! expDiff ) {
-            sigZ -= sigC;
-            if (
-                ! sigZ && ! sig128Z[indexWord( 4, 1 )]
-                    && ! sig128Z[indexWord( 4, 0 )]
-            ) {
-                goto completeCancellation;
-            }
-            sig128Z[indexWord( 4, 3 )] = sigZ>>32;
-            sig128Z[indexWord( 4, 2 )] = sigZ;
-            if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {
-                signZ = ! signZ;
-                softfloat_negX128M( sig128Z );
-            }
-        } else {
-            softfloat_sub128M( sig128Z, sig128C, sig128Z );
-            if ( 1 < expDiff ) {
-                sigZ =
-                    (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
-                        | sig128Z[indexWord( 4, 2 )];
-                if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
-                    --expZ;
-                    sigZ <<= 1;
-                }
-                goto sigZ;
-            }
-        }
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        shiftDist = 0;
-        sigZ =
-            (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
-                | sig128Z[indexWord( 4, 2 )];
-        if ( ! sigZ ) {
-            shiftDist = 64;
-            sigZ =
-                (uint64_t) sig128Z[indexWord( 4, 1 )]<<32
-                    | sig128Z[indexWord( 4, 0 )];
-        }
-        shiftDist += softfloat_countLeadingZeros64( sigZ ) - 1;
-        if ( shiftDist ) {
-            expZ -= shiftDist;
-            softfloat_shiftLeft128M( sig128Z, shiftDist, sig128Z );
-            sigZ =
-                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
-                    | sig128Z[indexWord( 4, 2 )];
-        }
-    }
- sigZ:
-    if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
- roundPack:
-    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN_ABC:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
-    goto propagateNaN_ZC;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- infProdArg:
-    if ( magBits ) {
-        uiZ = packToF64UI( signZ, 0x7FF, 0 );
-        if ( expC != 0x7FF ) goto uiZ;
-        if ( sigC ) goto propagateNaN_ZC;
-        if ( signZ == signC ) goto uiZ;
-    }
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    uiZ = defaultNaNF64UI;
- propagateNaN_ZC:
-    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- zeroProd:
-    uiZ = uiC;
-    if ( ! (expC | sigC) && (signZ != signC) ) {
- completeCancellation:
-        uiZ =
-            packToF64UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    }
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+float64_t
+ softfloat_mulAddF64(
+     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
+{
+    bool signA;
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    bool signB;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    bool signC;
+    int_fast16_t expC;
+    uint_fast64_t sigC;
+    bool signZ;
+    uint_fast64_t magBits, uiZ;
+    struct exp16_sig64 normExpSig;
+    int_fast16_t expZ;
+    struct uint128 sig128Z;
+    uint_fast64_t sigZ;
+    int_fast16_t expDiff;
+    struct uint128 sig128C;
+    int_fast8_t shiftDist;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    signB = signF64UI( uiB );
+    expB  = expF64UI( uiB );
+    sigB  = fracF64UI( uiB );
+    signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);
+    expC  = expF64UI( uiC );
+    sigC  = fracF64UI( uiC );
+    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;
+        magBits = expB | sigB;
+        goto infProdArg;
+    }
+    if ( expB == 0x7FF ) {
+        if ( sigB ) goto propagateNaN_ABC;
+        magBits = expA | sigA;
+        goto infProdArg;
+    }
+    if ( expC == 0x7FF ) {
+        if ( sigC ) {
+            uiZ = 0;
+            goto propagateNaN_ZC;
+        }
+        uiZ = uiC;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF64Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FE;
+    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
+    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<10;
+    sig128Z = softfloat_mul64To128( sigA, sigB );
+    if ( sig128Z.v64 < UINT64_C( 0x2000000000000000 ) ) {
+        --expZ;
+        sig128Z =
+            softfloat_add128(
+                sig128Z.v64, sig128Z.v0, sig128Z.v64, sig128Z.v0 );
+    }
+    if ( ! expC ) {
+        if ( ! sigC ) {
+            --expZ;
+            sigZ = sig128Z.v64<<1 | (sig128Z.v0 != 0);
+            goto roundPack;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( sigC );
+        expC = normExpSig.exp;
+        sigC = normExpSig.sig;
+    }
+    sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<9;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expZ - expC;
+    if ( expDiff < 0 ) {
+        expZ = expC;
+        if ( (signZ == signC) || (expDiff < -1) ) {
+            sig128Z.v64 = softfloat_shiftRightJam64( sig128Z.v64, -expDiff );
+        } else {
+            sig128Z =
+                softfloat_shortShiftRightJam128( sig128Z.v64, sig128Z.v0, 1 );
+        }
+    } else if ( expDiff ) {
+        sig128C = softfloat_shiftRightJam128( sigC, 0, expDiff );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signZ == signC ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff <= 0 ) {
+            sigZ = (sigC + sig128Z.v64) | (sig128Z.v0 != 0);
+        } else {
+            sig128Z =
+                softfloat_add128(
+                    sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );
+            sigZ = sig128Z.v64 | (sig128Z.v0 != 0);
+        }
+        if ( sigZ < UINT64_C( 0x4000000000000000 ) ) {
+            --expZ;
+            sigZ <<= 1;
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff < 0 ) {
+            signZ = signC;
+            sig128Z = softfloat_sub128( sigC, 0, sig128Z.v64, sig128Z.v0 );
+        } else if ( ! expDiff ) {
+            sig128Z.v64 = sig128Z.v64 - sigC;
+            if ( ! (sig128Z.v64 | sig128Z.v0) ) goto completeCancellation;
+            if ( sig128Z.v64 & UINT64_C( 0x8000000000000000 ) ) {
+                signZ = ! signZ;
+                sig128Z = softfloat_sub128( 0, 0, sig128Z.v64, sig128Z.v0 );
+            }
+        } else {
+            sig128Z =
+                softfloat_sub128(
+                    sig128Z.v64, sig128Z.v0, sig128C.v64, sig128C.v0 );
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( ! sig128Z.v64 ) {
+            expZ -= 64;
+            sig128Z.v64 = sig128Z.v0;
+            sig128Z.v0 = 0;
+        }
+        shiftDist = softfloat_countLeadingZeros64( sig128Z.v64 ) - 1;
+        expZ -= shiftDist;
+        if ( shiftDist < 0 ) {
+            sigZ = softfloat_shortShiftRightJam64( sig128Z.v64, -shiftDist );
+        } else {
+            sig128Z =
+                softfloat_shortShiftLeft128(
+                    sig128Z.v64, sig128Z.v0, shiftDist );
+            sigZ = sig128Z.v64;
+        }
+        sigZ |= (sig128Z.v0 != 0);
+    }
+ roundPack:
+    return softfloat_roundPackToF64( signZ, expZ, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN_ABC:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    goto propagateNaN_ZC;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infProdArg:
+    if ( magBits ) {
+        uiZ = packToF64UI( signZ, 0x7FF, 0 );
+        if ( expC != 0x7FF ) goto uiZ;
+        if ( sigC ) goto propagateNaN_ZC;
+        if ( signZ == signC ) goto uiZ;
+    }
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF64UI;
+ propagateNaN_ZC:
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    uiZ = uiC;
+    if ( ! (expC | sigC) && (signZ != signC) ) {
+ completeCancellation:
+        uiZ =
+            packToF64UI(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#else
+
+float64_t
+ softfloat_mulAddF64(
+     uint_fast64_t uiA, uint_fast64_t uiB, uint_fast64_t uiC, uint_fast8_t op )
+{
+    bool signA;
+    int_fast16_t expA;
+    uint64_t sigA;
+    bool signB;
+    int_fast16_t expB;
+    uint64_t sigB;
+    bool signC;
+    int_fast16_t expC;
+    uint64_t sigC;
+    bool signZ;
+    uint64_t magBits, uiZ;
+    struct exp16_sig64 normExpSig;
+    int_fast16_t expZ;
+    uint32_t sig128Z[4];
+    uint64_t sigZ;
+    int_fast16_t shiftDist, expDiff;
+    uint32_t sig128C[4];
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    signA = signF64UI( uiA );
+    expA  = expF64UI( uiA );
+    sigA  = fracF64UI( uiA );
+    signB = signF64UI( uiB );
+    expB  = expF64UI( uiB );
+    sigB  = fracF64UI( uiB );
+    signC = signF64UI( uiC ) ^ (op == softfloat_mulAdd_subC);
+    expC  = expF64UI( uiC );
+    sigC  = fracF64UI( uiC );
+    signZ = signA ^ signB ^ (op == softfloat_mulAdd_subProd);
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( expA == 0x7FF ) {
+        if ( sigA || ((expB == 0x7FF) && sigB) ) goto propagateNaN_ABC;
+        magBits = expB | sigB;
+        goto infProdArg;
+    }
+    if ( expB == 0x7FF ) {
+        if ( sigB ) goto propagateNaN_ABC;
+        magBits = expA | sigA;
+        goto infProdArg;
+    }
+    if ( expC == 0x7FF ) {
+        if ( sigC ) {
+            uiZ = 0;
+            goto propagateNaN_ZC;
+        }
+        uiZ = uiC;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( ! expA ) {
+        if ( ! sigA ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF64Sig( sigA );
+        expA = normExpSig.exp;
+        sigA = normExpSig.sig;
+    }
+    if ( ! expB ) {
+        if ( ! sigB ) goto zeroProd;
+        normExpSig = softfloat_normSubnormalF64Sig( sigB );
+        expB = normExpSig.exp;
+        sigB = normExpSig.sig;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA + expB - 0x3FE;
+    sigA = (sigA | UINT64_C( 0x0010000000000000 ))<<10;
+    sigB = (sigB | UINT64_C( 0x0010000000000000 ))<<11;
+    softfloat_mul64To128M( sigA, sigB, sig128Z );
+    sigZ =
+        (uint64_t) sig128Z[indexWord( 4, 3 )]<<32 | sig128Z[indexWord( 4, 2 )];
+    shiftDist = 0;
+    if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
+        --expZ;
+        shiftDist = -1;
+    }
+    if ( ! expC ) {
+        if ( ! sigC ) {
+            if ( shiftDist ) sigZ <<= 1;
+            goto sigZ;
+        }
+        normExpSig = softfloat_normSubnormalF64Sig( sigC );
+        expC = normExpSig.exp;
+        sigC = normExpSig.sig;
+    }
+    sigC = (sigC | UINT64_C( 0x0010000000000000 ))<<10;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expZ - expC;
+    if ( expDiff < 0 ) {
+        expZ = expC;
+        if ( (signZ == signC) || (expDiff < -1) ) {
+            shiftDist -= expDiff;
+            if ( shiftDist) {
+                sigZ = softfloat_shiftRightJam64( sigZ, shiftDist );
+            }
+        } else {
+            if ( ! shiftDist ) {
+                softfloat_shortShiftRight128M( sig128Z, 1, sig128Z );
+            }
+        }
+    } else {
+        if ( shiftDist ) softfloat_add128M( sig128Z, sig128Z, sig128Z );
+        if ( ! expDiff ) {
+            sigZ =
+                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
+                    | sig128Z[indexWord( 4, 2 )];
+        } else {
+            sig128C[indexWord( 4, 3 )] = sigC>>32;
+            sig128C[indexWord( 4, 2 )] = sigC;
+            sig128C[indexWord( 4, 1 )] = 0;
+            sig128C[indexWord( 4, 0 )] = 0;
+            softfloat_shiftRightJam128M( sig128C, expDiff, sig128C );
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( signZ == signC ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff <= 0 ) {
+            sigZ += sigC;
+        } else {
+            softfloat_add128M( sig128Z, sig128C, sig128Z );
+            sigZ =
+                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
+                    | sig128Z[indexWord( 4, 2 )];
+        }
+        if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {
+            ++expZ;
+            sigZ = softfloat_shortShiftRightJam64( sigZ, 1 );
+        }
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expDiff < 0 ) {
+            signZ = signC;
+            if ( expDiff < -1 ) {
+                sigZ = sigC - sigZ;
+                if (
+                    sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )]
+                ) {
+                    sigZ = (sigZ - 1) | 1;
+                }
+                if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
+                    --expZ;
+                    sigZ <<= 1;
+                }
+                goto roundPack;
+            } else {
+                sig128C[indexWord( 4, 3 )] = sigC>>32;
+                sig128C[indexWord( 4, 2 )] = sigC;
+                sig128C[indexWord( 4, 1 )] = 0;
+                sig128C[indexWord( 4, 0 )] = 0;
+                softfloat_sub128M( sig128C, sig128Z, sig128Z );
+            }
+        } else if ( ! expDiff ) {
+            sigZ -= sigC;
+            if (
+                ! sigZ && ! sig128Z[indexWord( 4, 1 )]
+                    && ! sig128Z[indexWord( 4, 0 )]
+            ) {
+                goto completeCancellation;
+            }
+            sig128Z[indexWord( 4, 3 )] = sigZ>>32;
+            sig128Z[indexWord( 4, 2 )] = sigZ;
+            if ( sigZ & UINT64_C( 0x8000000000000000 ) ) {
+                signZ = ! signZ;
+                softfloat_negX128M( sig128Z );
+            }
+        } else {
+            softfloat_sub128M( sig128Z, sig128C, sig128Z );
+            if ( 1 < expDiff ) {
+                sigZ =
+                    (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
+                        | sig128Z[indexWord( 4, 2 )];
+                if ( ! (sigZ & UINT64_C( 0x4000000000000000 )) ) {
+                    --expZ;
+                    sigZ <<= 1;
+                }
+                goto sigZ;
+            }
+        }
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        shiftDist = 0;
+        sigZ =
+            (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
+                | sig128Z[indexWord( 4, 2 )];
+        if ( ! sigZ ) {
+            shiftDist = 64;
+            sigZ =
+                (uint64_t) sig128Z[indexWord( 4, 1 )]<<32
+                    | sig128Z[indexWord( 4, 0 )];
+        }
+        shiftDist += softfloat_countLeadingZeros64( sigZ ) - 1;
+        if ( shiftDist ) {
+            expZ -= shiftDist;
+            softfloat_shiftLeft128M( sig128Z, shiftDist, sig128Z );
+            sigZ =
+                (uint64_t) sig128Z[indexWord( 4, 3 )]<<32
+                    | sig128Z[indexWord( 4, 2 )];
+        }
+    }
+ sigZ:
+    if ( sig128Z[indexWord( 4, 1 )] || sig128Z[indexWord( 4, 0 )] ) sigZ |= 1;
+ roundPack:
+    return softfloat_roundPackToF64( signZ, expZ - 1, sigZ );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN_ABC:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+    goto propagateNaN_ZC;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ infProdArg:
+    if ( magBits ) {
+        uiZ = packToF64UI( signZ, 0x7FF, 0 );
+        if ( expC != 0x7FF ) goto uiZ;
+        if ( sigC ) goto propagateNaN_ZC;
+        if ( signZ == signC ) goto uiZ;
+    }
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    uiZ = defaultNaNF64UI;
+ propagateNaN_ZC:
+    uiZ = softfloat_propagateNaNF64UI( uiZ, uiC );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ zeroProd:
+    uiZ = uiC;
+    if ( ! (expC | sigC) && (signZ != signC) ) {
+ completeCancellation:
+        uiZ =
+            packToF64UI(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    }
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_negXM.c b/softfloat/source/s_negXM.c
index ec8c928..bb1c5a1 100644
--- a/softfloat/source/s_negXM.c
+++ b/softfloat/source/s_negXM.c
@@ -1,63 +1,63 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_negXM
-
-void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr )
-{
-    unsigned int index, lastIndex;
-    uint_fast8_t carry;
-    uint32_t word;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    carry = 1;
-    for (;;) {
-        word = ~zPtr[index] + carry;
-        zPtr[index] = word;
-        if ( index == lastIndex ) break;
-        index += wordIncr;
-        if ( word ) carry = 0;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_negXM
+
+void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr )
+{
+    unsigned int index, lastIndex;
+    uint_fast8_t carry;
+    uint32_t word;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    carry = 1;
+    for (;;) {
+        word = ~zPtr[index] + carry;
+        zPtr[index] = word;
+        if ( index == lastIndex ) break;
+        index += wordIncr;
+        if ( word ) carry = 0;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_normExtF80SigM.c b/softfloat/source/s_normExtF80SigM.c
index acc54dc..fabe91c 100644
--- a/softfloat/source/s_normExtF80SigM.c
+++ b/softfloat/source/s_normExtF80SigM.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-int softfloat_normExtF80SigM( uint64_t *sigPtr )
-{
-    uint64_t sig;
-    int_fast8_t shiftDist;
-
-    sig = *sigPtr;
-    shiftDist = softfloat_countLeadingZeros64( sig );
-    *sigPtr = sig<<shiftDist;
-    return -shiftDist;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+int softfloat_normExtF80SigM( uint64_t *sigPtr )
+{
+    uint64_t sig;
+    int_fast8_t shiftDist;
+
+    sig = *sigPtr;
+    shiftDist = softfloat_countLeadingZeros64( sig );
+    *sigPtr = sig<<shiftDist;
+    return -shiftDist;
+
+}
+
diff --git a/softfloat/source/s_normRoundPackMToExtF80M.c b/softfloat/source/s_normRoundPackMToExtF80M.c
index 88b69cd..2a8988f 100644
--- a/softfloat/source/s_normRoundPackMToExtF80M.c
+++ b/softfloat/source/s_normRoundPackMToExtF80M.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-void
- softfloat_normRoundPackMToExtF80M(
-     bool sign,
-     int32_t exp,
-     uint32_t *extSigPtr,
-     uint_fast8_t roundingPrecision,
-     struct extFloat80M *zSPtr
- )
-{
-    int_fast16_t shiftDist;
-    uint32_t wordSig;
-
-    shiftDist = 0;
-    wordSig = extSigPtr[indexWord( 3, 2 )];
-    if ( ! wordSig ) {
-        shiftDist = 32;
-        wordSig = extSigPtr[indexWord( 3, 1 )];
-        if ( ! wordSig ) {
-            shiftDist = 64;
-            wordSig = extSigPtr[indexWord( 3, 0 )];
-            if ( ! wordSig ) {
-                zSPtr->signExp = packToExtF80UI64( sign, 0 );
-                zSPtr->signif = 0;
-                return;
-            }
-        }
-    }
-    shiftDist += softfloat_countLeadingZeros32( wordSig );
-    if ( shiftDist ) {
-        exp -= shiftDist;
-        softfloat_shiftLeft96M( extSigPtr, shiftDist, extSigPtr );
-    }
-    softfloat_roundPackMToExtF80M(
-        sign, exp, extSigPtr, roundingPrecision, zSPtr );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+void
+ softfloat_normRoundPackMToExtF80M(
+     bool sign,
+     int32_t exp,
+     uint32_t *extSigPtr,
+     uint_fast8_t roundingPrecision,
+     struct extFloat80M *zSPtr
+ )
+{
+    int_fast16_t shiftDist;
+    uint32_t wordSig;
+
+    shiftDist = 0;
+    wordSig = extSigPtr[indexWord( 3, 2 )];
+    if ( ! wordSig ) {
+        shiftDist = 32;
+        wordSig = extSigPtr[indexWord( 3, 1 )];
+        if ( ! wordSig ) {
+            shiftDist = 64;
+            wordSig = extSigPtr[indexWord( 3, 0 )];
+            if ( ! wordSig ) {
+                zSPtr->signExp = packToExtF80UI64( sign, 0 );
+                zSPtr->signif = 0;
+                return;
+            }
+        }
+    }
+    shiftDist += softfloat_countLeadingZeros32( wordSig );
+    if ( shiftDist ) {
+        exp -= shiftDist;
+        softfloat_shiftLeft96M( extSigPtr, shiftDist, extSigPtr );
+    }
+    softfloat_roundPackMToExtF80M(
+        sign, exp, extSigPtr, roundingPrecision, zSPtr );
+
+}
+
diff --git a/softfloat/source/s_normRoundPackMToF128M.c b/softfloat/source/s_normRoundPackMToF128M.c
index 3094559..b15d160 100644
--- a/softfloat/source/s_normRoundPackMToF128M.c
+++ b/softfloat/source/s_normRoundPackMToF128M.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-void
- softfloat_normRoundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
-{
-    const uint32_t *ptr;
-    int_fast16_t shiftDist;
-    uint32_t wordSig;
-
-    ptr = extSigPtr + indexWordHi( 5 );
-    shiftDist = 0;
-    for (;;) {
-        wordSig = *ptr;
-        if ( wordSig ) break;
-        shiftDist += 32;
-        if ( 160 <= shiftDist ) {
-            zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, 0, 0 );
-            zWPtr[indexWord( 4, 2 )] = 0;
-            zWPtr[indexWord( 4, 1 )] = 0;
-            zWPtr[indexWord( 4, 0 )] = 0;
-            return;
-        }
-        ptr -= wordIncr;
-    }
-    shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15;
-    if ( shiftDist ) {
-        exp -= shiftDist;
-        softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr );
-    }
-    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+void
+ softfloat_normRoundPackMToF128M(
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+{
+    const uint32_t *ptr;
+    int_fast16_t shiftDist;
+    uint32_t wordSig;
+
+    ptr = extSigPtr + indexWordHi( 5 );
+    shiftDist = 0;
+    for (;;) {
+        wordSig = *ptr;
+        if ( wordSig ) break;
+        shiftDist += 32;
+        if ( 160 <= shiftDist ) {
+            zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, 0, 0 );
+            zWPtr[indexWord( 4, 2 )] = 0;
+            zWPtr[indexWord( 4, 1 )] = 0;
+            zWPtr[indexWord( 4, 0 )] = 0;
+            return;
+        }
+        ptr -= wordIncr;
+    }
+    shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15;
+    if ( shiftDist ) {
+        exp -= shiftDist;
+        softfloat_shiftLeft160M( extSigPtr, shiftDist, extSigPtr );
+    }
+    softfloat_roundPackMToF128M( sign, exp, extSigPtr, zWPtr );
+
+}
+
diff --git a/softfloat/source/s_normRoundPackToExtF80.c b/softfloat/source/s_normRoundPackToExtF80.c
index 76e791d..2518bf4 100644
--- a/softfloat/source/s_normRoundPackToExtF80.c
+++ b/softfloat/source/s_normRoundPackToExtF80.c
@@ -1,71 +1,71 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-extFloat80_t
- softfloat_normRoundPackToExtF80(
-     bool sign,
-     int_fast32_t exp,
-     uint_fast64_t sig,
-     uint_fast64_t sigExtra,
-     uint_fast8_t roundingPrecision
- )
-{
-    int_fast8_t shiftDist;
-    struct uint128 sig128;
-
-    if ( ! sig ) {
-        exp -= 64;
-        sig = sigExtra;
-        sigExtra = 0;
-    }
-    shiftDist = softfloat_countLeadingZeros64( sig );
-    exp -= shiftDist;
-    if ( shiftDist ) {
-        sig128 = softfloat_shortShiftLeft128( sig, sigExtra, shiftDist );
-        sig = sig128.v64;
-        sigExtra = sig128.v0;
-    }
-    return
-        softfloat_roundPackToExtF80(
-            sign, exp, sig, sigExtra, roundingPrecision );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+extFloat80_t
+ softfloat_normRoundPackToExtF80(
+     bool sign,
+     int_fast32_t exp,
+     uint_fast64_t sig,
+     uint_fast64_t sigExtra,
+     uint_fast8_t roundingPrecision
+ )
+{
+    int_fast8_t shiftDist;
+    struct uint128 sig128;
+
+    if ( ! sig ) {
+        exp -= 64;
+        sig = sigExtra;
+        sigExtra = 0;
+    }
+    shiftDist = softfloat_countLeadingZeros64( sig );
+    exp -= shiftDist;
+    if ( shiftDist ) {
+        sig128 = softfloat_shortShiftLeft128( sig, sigExtra, shiftDist );
+        sig = sig128.v64;
+        sigExtra = sig128.v0;
+    }
+    return
+        softfloat_roundPackToExtF80(
+            sign, exp, sig, sigExtra, roundingPrecision );
+
+}
+
diff --git a/softfloat/source/s_normRoundPackToF128.c b/softfloat/source/s_normRoundPackToF128.c
index 67f5b43..14cf28e 100644
--- a/softfloat/source/s_normRoundPackToF128.c
+++ b/softfloat/source/s_normRoundPackToF128.c
@@ -1,81 +1,81 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-float128_t
- softfloat_normRoundPackToF128(
-     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )
-{
-    int_fast8_t shiftDist;
-    struct uint128 sig128;
-    union ui128_f128 uZ;
-    uint_fast64_t sigExtra;
-    struct uint128_extra sig128Extra;
-
-    if ( ! sig64 ) {
-        exp -= 64;
-        sig64 = sig0;
-        sig0 = 0;
-    }
-    shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15;
-    exp -= shiftDist;
-    if ( 0 <= shiftDist ) {
-        if ( shiftDist ) {
-            sig128 = softfloat_shortShiftLeft128( sig64, sig0, shiftDist );
-            sig64 = sig128.v64;
-            sig0  = sig128.v0;
-        }
-        if ( (uint32_t) exp < 0x7FFD ) {
-            uZ.ui.v64 = packToF128UI64( sign, sig64 | sig0 ? exp : 0, sig64 );
-            uZ.ui.v0  = sig0;
-            return uZ.f;
-        }
-        sigExtra = 0;
-    } else {
-        sig128Extra =
-            softfloat_shortShiftRightJam128Extra( sig64, sig0, 0, -shiftDist );
-        sig64 = sig128Extra.v.v64;
-        sig0  = sig128Extra.v.v0;
-        sigExtra = sig128Extra.extra;
-    }
-    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+float128_t
+ softfloat_normRoundPackToF128(
+     bool sign, int_fast32_t exp, uint_fast64_t sig64, uint_fast64_t sig0 )
+{
+    int_fast8_t shiftDist;
+    struct uint128 sig128;
+    union ui128_f128 uZ;
+    uint_fast64_t sigExtra;
+    struct uint128_extra sig128Extra;
+
+    if ( ! sig64 ) {
+        exp -= 64;
+        sig64 = sig0;
+        sig0 = 0;
+    }
+    shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15;
+    exp -= shiftDist;
+    if ( 0 <= shiftDist ) {
+        if ( shiftDist ) {
+            sig128 = softfloat_shortShiftLeft128( sig64, sig0, shiftDist );
+            sig64 = sig128.v64;
+            sig0  = sig128.v0;
+        }
+        if ( (uint32_t) exp < 0x7FFD ) {
+            uZ.ui.v64 = packToF128UI64( sign, sig64 | sig0 ? exp : 0, sig64 );
+            uZ.ui.v0  = sig0;
+            return uZ.f;
+        }
+        sigExtra = 0;
+    } else {
+        sig128Extra =
+            softfloat_shortShiftRightJam128Extra( sig64, sig0, 0, -shiftDist );
+        sig64 = sig128Extra.v.v64;
+        sig0  = sig128Extra.v.v0;
+        sigExtra = sig128Extra.extra;
+    }
+    return softfloat_roundPackToF128( sign, exp, sig64, sig0, sigExtra );
+
+}
+
diff --git a/softfloat/source/s_normRoundPackToF16.c b/softfloat/source/s_normRoundPackToF16.c
index 1d184d5..008c5f1 100644
--- a/softfloat/source/s_normRoundPackToF16.c
+++ b/softfloat/source/s_normRoundPackToF16.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-float16_t
- softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
-{
-    int_fast8_t shiftDist;
-    union ui16_f16 uZ;
-
-    shiftDist = softfloat_countLeadingZeros16( sig ) - 1;
-    exp -= shiftDist;
-    if ( (4 <= shiftDist) && ((unsigned int) exp < 0x1D) ) {
-        uZ.ui = packToF16UI( sign, sig ? exp : 0, sig<<(shiftDist - 4) );
-        return uZ.f;
-    } else {
-        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+float16_t
+ softfloat_normRoundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+{
+    int_fast8_t shiftDist;
+    union ui16_f16 uZ;
+
+    shiftDist = softfloat_countLeadingZeros16( sig ) - 1;
+    exp -= shiftDist;
+    if ( (4 <= shiftDist) && ((unsigned int) exp < 0x1D) ) {
+        uZ.ui = packToF16UI( sign, sig ? exp : 0, sig<<(shiftDist - 4) );
+        return uZ.f;
+    } else {
+        return softfloat_roundPackToF16( sign, exp, sig<<shiftDist );
+    }
+
+}
+
diff --git a/softfloat/source/s_normRoundPackToF32.c b/softfloat/source/s_normRoundPackToF32.c
index 9fae916..28df737 100644
--- a/softfloat/source/s_normRoundPackToF32.c
+++ b/softfloat/source/s_normRoundPackToF32.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-float32_t
- softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
-{
-    int_fast8_t shiftDist;
-    union ui32_f32 uZ;
-
-    shiftDist = softfloat_countLeadingZeros32( sig ) - 1;
-    exp -= shiftDist;
-    if ( (7 <= shiftDist) && ((unsigned int) exp < 0xFD) ) {
-        uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) );
-        return uZ.f;
-    } else {
-        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+float32_t
+ softfloat_normRoundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+{
+    int_fast8_t shiftDist;
+    union ui32_f32 uZ;
+
+    shiftDist = softfloat_countLeadingZeros32( sig ) - 1;
+    exp -= shiftDist;
+    if ( (7 <= shiftDist) && ((unsigned int) exp < 0xFD) ) {
+        uZ.ui = packToF32UI( sign, sig ? exp : 0, sig<<(shiftDist - 7) );
+        return uZ.f;
+    } else {
+        return softfloat_roundPackToF32( sign, exp, sig<<shiftDist );
+    }
+
+}
+
diff --git a/softfloat/source/s_normRoundPackToF64.c b/softfloat/source/s_normRoundPackToF64.c
index 109141f..8c19ad8 100644
--- a/softfloat/source/s_normRoundPackToF64.c
+++ b/softfloat/source/s_normRoundPackToF64.c
@@ -1,58 +1,58 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-float64_t
- softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
-{
-    int_fast8_t shiftDist;
-    union ui64_f64 uZ;
-
-    shiftDist = softfloat_countLeadingZeros64( sig ) - 1;
-    exp -= shiftDist;
-    if ( (10 <= shiftDist) && ((unsigned int) exp < 0x7FD) ) {
-        uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<(shiftDist - 10) );
-        return uZ.f;
-    } else {
-        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+float64_t
+ softfloat_normRoundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+{
+    int_fast8_t shiftDist;
+    union ui64_f64 uZ;
+
+    shiftDist = softfloat_countLeadingZeros64( sig ) - 1;
+    exp -= shiftDist;
+    if ( (10 <= shiftDist) && ((unsigned int) exp < 0x7FD) ) {
+        uZ.ui = packToF64UI( sign, sig ? exp : 0, sig<<(shiftDist - 10) );
+        return uZ.f;
+    } else {
+        return softfloat_roundPackToF64( sign, exp, sig<<shiftDist );
+    }
+
+}
+
diff --git a/softfloat/source/s_normSubnormalBF16Sig.c b/softfloat/source/s_normSubnormalBF16Sig.c
new file mode 100644
index 0000000..b81baa9
--- /dev/null
+++ b/softfloat/source/s_normSubnormalBF16Sig.c
@@ -0,0 +1,52 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp8_sig16 softfloat_normSubnormalBF16Sig( uint_fast16_t sig )
+{
+    int_fast8_t shiftDist;
+    struct exp8_sig16 z;
+
+    shiftDist = softfloat_countLeadingZeros16( sig ) - 8;
+    z.exp = 1 - shiftDist;
+    z.sig = sig<<shiftDist;
+    return z;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalExtF80Sig.c b/softfloat/source/s_normSubnormalExtF80Sig.c
index c1d7788..e6f2e4b 100644
--- a/softfloat/source/s_normSubnormalExtF80Sig.c
+++ b/softfloat/source/s_normSubnormalExtF80Sig.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t sig )
-{
-    int_fast8_t shiftDist;
-    struct exp32_sig64 z;
-
-    shiftDist = softfloat_countLeadingZeros64( sig );
-    z.exp = -shiftDist;
-    z.sig = sig<<shiftDist;
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t sig )
+{
+    int_fast8_t shiftDist;
+    struct exp32_sig64 z;
+
+    shiftDist = softfloat_countLeadingZeros64( sig );
+    z.exp = -shiftDist;
+    z.sig = sig<<shiftDist;
+    return z;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalF128Sig.c b/softfloat/source/s_normSubnormalF128Sig.c
index 597d558..a67763f 100644
--- a/softfloat/source/s_normSubnormalF128Sig.c
+++ b/softfloat/source/s_normSubnormalF128Sig.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-struct exp32_sig128
- softfloat_normSubnormalF128Sig( uint_fast64_t sig64, uint_fast64_t sig0 )
-{
-    int_fast8_t shiftDist;
-    struct exp32_sig128 z;
-
-    if ( ! sig64 ) {
-        shiftDist = softfloat_countLeadingZeros64( sig0 ) - 15;
-        z.exp = -63 - shiftDist;
-        if ( shiftDist < 0 ) {
-            z.sig.v64 = sig0>>-shiftDist;
-            z.sig.v0  = sig0<<(shiftDist & 63);
-        } else {
-            z.sig.v64 = sig0<<shiftDist;
-            z.sig.v0  = 0;
-        }
-    } else {
-        shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15;
-        z.exp = 1 - shiftDist;
-        z.sig = softfloat_shortShiftLeft128( sig64, sig0, shiftDist );
-    }
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp32_sig128
+ softfloat_normSubnormalF128Sig( uint_fast64_t sig64, uint_fast64_t sig0 )
+{
+    int_fast8_t shiftDist;
+    struct exp32_sig128 z;
+
+    if ( ! sig64 ) {
+        shiftDist = softfloat_countLeadingZeros64( sig0 ) - 15;
+        z.exp = -63 - shiftDist;
+        if ( shiftDist < 0 ) {
+            z.sig.v64 = sig0>>-shiftDist;
+            z.sig.v0  = sig0<<(shiftDist & 63);
+        } else {
+            z.sig.v64 = sig0<<shiftDist;
+            z.sig.v0  = 0;
+        }
+    } else {
+        shiftDist = softfloat_countLeadingZeros64( sig64 ) - 15;
+        z.exp = 1 - shiftDist;
+        z.sig = softfloat_shortShiftLeft128( sig64, sig0, shiftDist );
+    }
+    return z;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalF128SigM.c b/softfloat/source/s_normSubnormalF128SigM.c
index 7b8ced1..f2745de 100644
--- a/softfloat/source/s_normSubnormalF128SigM.c
+++ b/softfloat/source/s_normSubnormalF128SigM.c
@@ -1,61 +1,61 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-int softfloat_normSubnormalF128SigM( uint32_t *sigPtr )
-{
-    const uint32_t *ptr;
-    int_fast16_t shiftDist;
-    uint32_t wordSig;
-
-    ptr = sigPtr + indexWordHi( 4 );
-    shiftDist = 0;
-    for (;;) {
-        wordSig = *ptr;
-        if ( wordSig ) break;
-        shiftDist += 32;
-        if ( 128 <= shiftDist ) return 1;
-        ptr -= wordIncr;
-    }
-    shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15;
-    if ( shiftDist ) softfloat_shiftLeft128M( sigPtr, shiftDist, sigPtr );
-    return 1 - shiftDist;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+int softfloat_normSubnormalF128SigM( uint32_t *sigPtr )
+{
+    const uint32_t *ptr;
+    int_fast16_t shiftDist;
+    uint32_t wordSig;
+
+    ptr = sigPtr + indexWordHi( 4 );
+    shiftDist = 0;
+    for (;;) {
+        wordSig = *ptr;
+        if ( wordSig ) break;
+        shiftDist += 32;
+        if ( 128 <= shiftDist ) return 1;
+        ptr -= wordIncr;
+    }
+    shiftDist += softfloat_countLeadingZeros32( wordSig ) - 15;
+    if ( shiftDist ) softfloat_shiftLeft128M( sigPtr, shiftDist, sigPtr );
+    return 1 - shiftDist;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalF16Sig.c b/softfloat/source/s_normSubnormalF16Sig.c
index bb92adf..94541c9 100644
--- a/softfloat/source/s_normSubnormalF16Sig.c
+++ b/softfloat/source/s_normSubnormalF16Sig.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t sig )
-{
-    int_fast8_t shiftDist;
-    struct exp8_sig16 z;
-
-    shiftDist = softfloat_countLeadingZeros16( sig ) - 5;
-    z.exp = 1 - shiftDist;
-    z.sig = sig<<shiftDist;
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t sig )
+{
+    int_fast8_t shiftDist;
+    struct exp8_sig16 z;
+
+    shiftDist = softfloat_countLeadingZeros16( sig ) - 5;
+    z.exp = 1 - shiftDist;
+    z.sig = sig<<shiftDist;
+    return z;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalF32Sig.c b/softfloat/source/s_normSubnormalF32Sig.c
index d4bff9b..b48e10d 100644
--- a/softfloat/source/s_normSubnormalF32Sig.c
+++ b/softfloat/source/s_normSubnormalF32Sig.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig )
-{
-    int_fast8_t shiftDist;
-    struct exp16_sig32 z;
-
-    shiftDist = softfloat_countLeadingZeros32( sig ) - 8;
-    z.exp = 1 - shiftDist;
-    z.sig = sig<<shiftDist;
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t sig )
+{
+    int_fast8_t shiftDist;
+    struct exp16_sig32 z;
+
+    shiftDist = softfloat_countLeadingZeros32( sig ) - 8;
+    z.exp = 1 - shiftDist;
+    z.sig = sig<<shiftDist;
+    return z;
+
+}
+
diff --git a/softfloat/source/s_normSubnormalF64Sig.c b/softfloat/source/s_normSubnormalF64Sig.c
index 0c63b97..f786159 100644
--- a/softfloat/source/s_normSubnormalF64Sig.c
+++ b/softfloat/source/s_normSubnormalF64Sig.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig )
-{
-    int_fast8_t shiftDist;
-    struct exp16_sig64 z;
-
-    shiftDist = softfloat_countLeadingZeros64( sig ) - 11;
-    z.exp = 1 - shiftDist;
-    z.sig = sig<<shiftDist;
-    return z;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t sig )
+{
+    int_fast8_t shiftDist;
+    struct exp16_sig64 z;
+
+    shiftDist = softfloat_countLeadingZeros64( sig ) - 11;
+    z.exp = 1 - shiftDist;
+    z.sig = sig<<shiftDist;
+    return z;
+
+}
+
diff --git a/softfloat/source/s_remStepMBy32.c b/softfloat/source/s_remStepMBy32.c
index dd7d78d..0f249b9 100644
--- a/softfloat/source/s_remStepMBy32.c
+++ b/softfloat/source/s_remStepMBy32.c
@@ -1,86 +1,86 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_remStepMBy32
-
-void
- softfloat_remStepMBy32(
-     uint_fast8_t size_words,
-     const uint32_t *remPtr,
-     uint_fast8_t dist,
-     const uint32_t *bPtr,
-     uint32_t q,
-     uint32_t *zPtr
- )
-{
-    unsigned int index, lastIndex;
-    uint64_t dwordProd;
-    uint32_t wordRem, wordShiftedRem, wordProd;
-    uint_fast8_t uNegDist, borrow;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    dwordProd = (uint64_t) bPtr[index] * q;
-    wordRem = remPtr[index];
-    wordShiftedRem = wordRem<<dist;
-    wordProd = dwordProd;
-    zPtr[index] = wordShiftedRem - wordProd;
-    if ( index != lastIndex ) {
-        uNegDist = -dist;
-        borrow = (wordShiftedRem < wordProd);
-        for (;;) {
-            wordShiftedRem = wordRem>>(uNegDist & 31);
-            index += wordIncr;
-            dwordProd = (uint64_t) bPtr[index] * q + (dwordProd>>32);
-            wordRem = remPtr[index];
-            wordShiftedRem |= wordRem<<dist;
-            wordProd = dwordProd;
-            zPtr[index] = wordShiftedRem - wordProd - borrow;
-            if ( index == lastIndex ) break;
-            borrow =
-                borrow ? (wordShiftedRem <= wordProd)
-                    : (wordShiftedRem < wordProd);
-        }
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_remStepMBy32
+
+void
+ softfloat_remStepMBy32(
+     uint_fast8_t size_words,
+     const uint32_t *remPtr,
+     uint_fast8_t dist,
+     const uint32_t *bPtr,
+     uint32_t q,
+     uint32_t *zPtr
+ )
+{
+    unsigned int index, lastIndex;
+    uint64_t dwordProd;
+    uint32_t wordRem, wordShiftedRem, wordProd;
+    uint_fast8_t uNegDist, borrow;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    dwordProd = (uint64_t) bPtr[index] * q;
+    wordRem = remPtr[index];
+    wordShiftedRem = wordRem<<dist;
+    wordProd = dwordProd;
+    zPtr[index] = wordShiftedRem - wordProd;
+    if ( index != lastIndex ) {
+        uNegDist = -dist;
+        borrow = (wordShiftedRem < wordProd);
+        for (;;) {
+            wordShiftedRem = wordRem>>(uNegDist & 31);
+            index += wordIncr;
+            dwordProd = (uint64_t) bPtr[index] * q + (dwordProd>>32);
+            wordRem = remPtr[index];
+            wordShiftedRem |= wordRem<<dist;
+            wordProd = dwordProd;
+            zPtr[index] = wordShiftedRem - wordProd - borrow;
+            if ( index == lastIndex ) break;
+            borrow =
+                borrow ? (wordShiftedRem <= wordProd)
+                    : (wordShiftedRem < wordProd);
+        }
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_roundMToI64.c b/softfloat/source/s_roundMToI64.c
index 66f43b2..557a532 100644
--- a/softfloat/source/s_roundMToI64.c
+++ b/softfloat/source/s_roundMToI64.c
@@ -1,102 +1,102 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t
- softfloat_roundMToI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
-{
-    uint64_t sig;
-    uint32_t sigExtra;
-    union { uint64_t ui; int64_t i; } uZ;
-    int64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig =
-        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
-            | extSigPtr[indexWord( 3, 1 )];
-    sigExtra = extSigPtr[indexWordLo( 3 )];
-    if (
-        (roundingMode == softfloat_round_near_maxMag)
-            || (roundingMode == softfloat_round_near_even)
-    ) {
-        if ( 0x80000000 <= sigExtra ) goto increment;
-    } else {
-        if (
-            sigExtra
-                && (sign
-                        ? (roundingMode == softfloat_round_min)
-#ifdef SOFTFLOAT_ROUND_ODD
-                              || (roundingMode == softfloat_round_odd)
-#endif
-                        : (roundingMode == softfloat_round_max))
-        ) {
- increment:
-            ++sig;
-            if ( !sig ) goto invalid;
-            if (
-                (sigExtra == 0x80000000)
-                    && (roundingMode == softfloat_round_near_even)
-            ) {
-                sig &= ~(uint_fast64_t) 1;
-            }
-        }
-    }
-    uZ.ui = sign ? -sig : sig;
-    z = uZ.i;
-    if ( z && ((z < 0) ^ sign) ) goto invalid;
-    if ( sigExtra ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) z |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t
+ softfloat_roundMToI64(
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+{
+    uint64_t sig;
+    uint32_t sigExtra;
+    union { uint64_t ui; int64_t i; } uZ;
+    int64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig =
+        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
+            | extSigPtr[indexWord( 3, 1 )];
+    sigExtra = extSigPtr[indexWordLo( 3 )];
+    if (
+        (roundingMode == softfloat_round_near_maxMag)
+            || (roundingMode == softfloat_round_near_even)
+    ) {
+        if ( 0x80000000 <= sigExtra ) goto increment;
+    } else {
+        if (
+            sigExtra
+                && (sign
+                        ? (roundingMode == softfloat_round_min)
+#ifdef SOFTFLOAT_ROUND_ODD
+                              || (roundingMode == softfloat_round_odd)
+#endif
+                        : (roundingMode == softfloat_round_max))
+        ) {
+ increment:
+            ++sig;
+            if ( !sig ) goto invalid;
+            if (
+                (sigExtra == 0x80000000)
+                    && (roundingMode == softfloat_round_near_even)
+            ) {
+                sig &= ~(uint_fast64_t) 1;
+            }
+        }
+    }
+    uZ.ui = sign ? -sig : sig;
+    z = uZ.i;
+    if ( z && ((z < 0) ^ sign) ) goto invalid;
+    if ( sigExtra ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) z |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_roundMToUI64.c b/softfloat/source/s_roundMToUI64.c
index 196f537..c911474 100644
--- a/softfloat/source/s_roundMToUI64.c
+++ b/softfloat/source/s_roundMToUI64.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t
- softfloat_roundMToUI64(
-     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
-{
-    uint64_t sig;
-    uint32_t sigExtra;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig =
-        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
-            | extSigPtr[indexWord( 3, 1 )];
-    sigExtra = extSigPtr[indexWordLo( 3 )];
-    if (
-        (roundingMode == softfloat_round_near_maxMag)
-            || (roundingMode == softfloat_round_near_even)
-    ) {
-        if ( 0x80000000 <= sigExtra ) goto increment;
-    } else {
-        if ( sign ) {
-            if ( !(sig | sigExtra) ) return 0;
-            if ( roundingMode == softfloat_round_min ) goto invalid;
-#ifdef SOFTFLOAT_ROUND_ODD
-            if ( roundingMode == softfloat_round_odd ) goto invalid;
-#endif
-        } else {
-            if ( (roundingMode == softfloat_round_max) && sigExtra ) {
- increment:
-                ++sig;
-                if ( !sig ) goto invalid;
-                if (
-                    (sigExtra == 0x80000000)
-                        && (roundingMode == softfloat_round_near_even)
-                ) {
-                    sig &= ~(uint_fast64_t) 1;
-                }
-            }
-        }
-    }
-    if ( sign && sig ) goto invalid;
-    if ( sigExtra ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) sig |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sig;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t
+ softfloat_roundMToUI64(
+     bool sign, uint32_t *extSigPtr, uint_fast8_t roundingMode, bool exact )
+{
+    uint64_t sig;
+    uint32_t sigExtra;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig =
+        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
+            | extSigPtr[indexWord( 3, 1 )];
+    sigExtra = extSigPtr[indexWordLo( 3 )];
+    if (
+        (roundingMode == softfloat_round_near_maxMag)
+            || (roundingMode == softfloat_round_near_even)
+    ) {
+        if ( 0x80000000 <= sigExtra ) goto increment;
+    } else {
+        if ( sign ) {
+            if ( !(sig | sigExtra) ) return 0;
+            if ( roundingMode == softfloat_round_min ) goto invalid;
+#ifdef SOFTFLOAT_ROUND_ODD
+            if ( roundingMode == softfloat_round_odd ) goto invalid;
+#endif
+        } else {
+            if ( (roundingMode == softfloat_round_max) && sigExtra ) {
+ increment:
+                ++sig;
+                if ( !sig ) goto invalid;
+                if (
+                    (sigExtra == 0x80000000)
+                        && (roundingMode == softfloat_round_near_even)
+                ) {
+                    sig &= ~(uint_fast64_t) 1;
+                }
+            }
+        }
+    }
+    if ( sign && sig ) goto invalid;
+    if ( sigExtra ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) sig |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sig;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_roundPackMToExtF80M.c b/softfloat/source/s_roundPackMToExtF80M.c
index 0862015..e9d3c3b 100644
--- a/softfloat/source/s_roundPackMToExtF80M.c
+++ b/softfloat/source/s_roundPackMToExtF80M.c
@@ -1,256 +1,256 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-void
- softfloat_roundPackMToExtF80M(
-     bool sign,
-     int32_t exp,
-     uint32_t *extSigPtr,
-     uint_fast8_t roundingPrecision,
-     struct extFloat80M *zSPtr
- )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint64_t sig, roundIncrement, roundMask, roundBits;
-    bool isTiny;
-    uint32_t sigExtra;
-    bool doIncrement;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    sig =
-        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
-            | extSigPtr[indexWord( 3, 1 )];
-    if ( roundingPrecision == 80 ) goto precision80;
-    if ( roundingPrecision == 64 ) {
-        roundIncrement = UINT64_C( 0x0000000000000400 );
-        roundMask = UINT64_C( 0x00000000000007FF );
-    } else if ( roundingPrecision == 32 ) {
-        roundIncrement = UINT64_C( 0x0000008000000000 );
-        roundMask = UINT64_C( 0x000000FFFFFFFFFF );
-    } else {
-        goto precision80;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( extSigPtr[indexWordLo( 3 )] ) sig |= 1;
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        roundIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                ? roundMask
-                : 0;
-    }
-    roundBits = sig & roundMask;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
-        if ( exp <= 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < 0)
-                || (sig <= (uint64_t) (sig + roundIncrement));
-            sig = softfloat_shiftRightJam64( sig, 1 - exp );
-            roundBits = sig & roundMask;
-            if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-                if ( roundingMode == softfloat_round_odd ) {
-                    sig |= roundMask + 1;
-                }
-#endif
-            }
-            sig += roundIncrement;
-            exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
-            roundIncrement = roundMask + 1;
-            if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
-                roundMask |= roundIncrement;
-            }
-            sig &= ~roundMask;
-            goto packReturn;
-        }
-        if (
-               (0x7FFE < exp)
-            || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))
-        ) {
-            goto overflow;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig = (sig & ~roundMask) | (roundMask + 1);
-            goto packReturn;
-        }
-#endif
-    }
-    sig += roundIncrement;
-    if ( sig < roundIncrement ) {
-        ++exp;
-        sig = UINT64_C( 0x8000000000000000 );
-    }
-    roundIncrement = roundMask + 1;
-    if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
-        roundMask |= roundIncrement;
-    }
-    sig &= ~roundMask;
-    goto packReturn;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- precision80:
-    sigExtra = extSigPtr[indexWordLo( 3 )];
-    doIncrement = (0x80000000 <= sigExtra);
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        doIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                && sigExtra;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
-        if ( exp <= 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < 0)
-                || ! doIncrement
-                || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));
-            softfloat_shiftRightJam96M( extSigPtr, 1 - exp, extSigPtr );
-            exp = 0;
-            sig =
-                (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
-                    | extSigPtr[indexWord( 3, 1 )];
-            sigExtra = extSigPtr[indexWordLo( 3 )];
-            if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-                if ( roundingMode == softfloat_round_odd ) {
-                    sig |= 1;
-                    goto packReturn;
-                }
-#endif
-            }
-            doIncrement = (0x80000000 <= sigExtra);
-            if (
-                ! roundNearEven
-                    && (roundingMode != softfloat_round_near_maxMag)
-            ) {
-                doIncrement =
-                    (roundingMode
-                         == (sign ? softfloat_round_min : softfloat_round_max))
-                        && sigExtra;
-            }
-            if ( doIncrement ) {
-                ++sig;
-                sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven);
-                exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
-            }
-            goto packReturn;
-        }
-        if (
-               (0x7FFE < exp)
-            || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))
-                    && doIncrement)
-        ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            roundMask = 0;
- overflow:
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            if (
-                   roundNearEven
-                || (roundingMode == softfloat_round_near_maxMag)
-                || (roundingMode
-                        == (sign ? softfloat_round_min : softfloat_round_max))
-            ) {
-                exp = 0x7FFF;
-                sig = UINT64_C( 0x8000000000000000 );
-            } else {
-                exp = 0x7FFE;
-                sig = ~roundMask;
-            }
-            goto packReturn;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    if ( doIncrement ) {
-        ++sig;
-        if ( ! sig ) {
-            ++exp;
-            sig = UINT64_C( 0x8000000000000000 );
-        } else {
-            sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven);
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    zSPtr->signExp = packToExtF80UI64( sign, exp );
-    zSPtr->signif = sig;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+void
+ softfloat_roundPackMToExtF80M(
+     bool sign,
+     int32_t exp,
+     uint32_t *extSigPtr,
+     uint_fast8_t roundingPrecision,
+     struct extFloat80M *zSPtr
+ )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint64_t sig, roundIncrement, roundMask, roundBits;
+    bool isTiny;
+    uint32_t sigExtra;
+    bool doIncrement;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    sig =
+        (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
+            | extSigPtr[indexWord( 3, 1 )];
+    if ( roundingPrecision == 80 ) goto precision80;
+    if ( roundingPrecision == 64 ) {
+        roundIncrement = UINT64_C( 0x0000000000000400 );
+        roundMask = UINT64_C( 0x00000000000007FF );
+    } else if ( roundingPrecision == 32 ) {
+        roundIncrement = UINT64_C( 0x0000008000000000 );
+        roundMask = UINT64_C( 0x000000FFFFFFFFFF );
+    } else {
+        goto precision80;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( extSigPtr[indexWordLo( 3 )] ) sig |= 1;
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? roundMask
+                : 0;
+    }
+    roundBits = sig & roundMask;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
+        if ( exp <= 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < 0)
+                || (sig <= (uint64_t) (sig + roundIncrement));
+            sig = softfloat_shiftRightJam64( sig, 1 - exp );
+            roundBits = sig & roundMask;
+            if ( roundBits ) {
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+                if ( roundingMode == softfloat_round_odd ) {
+                    sig |= roundMask + 1;
+                }
+#endif
+            }
+            sig += roundIncrement;
+            exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
+            roundIncrement = roundMask + 1;
+            if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
+                roundMask |= roundIncrement;
+            }
+            sig &= ~roundMask;
+            goto packReturn;
+        }
+        if (
+               (0x7FFE < exp)
+            || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))
+        ) {
+            goto overflow;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig = (sig & ~roundMask) | (roundMask + 1);
+            goto packReturn;
+        }
+#endif
+    }
+    sig += roundIncrement;
+    if ( sig < roundIncrement ) {
+        ++exp;
+        sig = UINT64_C( 0x8000000000000000 );
+    }
+    roundIncrement = roundMask + 1;
+    if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
+        roundMask |= roundIncrement;
+    }
+    sig &= ~roundMask;
+    goto packReturn;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ precision80:
+    sigExtra = extSigPtr[indexWordLo( 3 )];
+    doIncrement = (0x80000000 <= sigExtra);
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        doIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                && sigExtra;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
+        if ( exp <= 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < 0)
+                || ! doIncrement
+                || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));
+            softfloat_shiftRightJam96M( extSigPtr, 1 - exp, extSigPtr );
+            exp = 0;
+            sig =
+                (uint64_t) extSigPtr[indexWord( 3, 2 )]<<32
+                    | extSigPtr[indexWord( 3, 1 )];
+            sigExtra = extSigPtr[indexWordLo( 3 )];
+            if ( sigExtra ) {
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+                if ( roundingMode == softfloat_round_odd ) {
+                    sig |= 1;
+                    goto packReturn;
+                }
+#endif
+            }
+            doIncrement = (0x80000000 <= sigExtra);
+            if (
+                ! roundNearEven
+                    && (roundingMode != softfloat_round_near_maxMag)
+            ) {
+                doIncrement =
+                    (roundingMode
+                         == (sign ? softfloat_round_min : softfloat_round_max))
+                        && sigExtra;
+            }
+            if ( doIncrement ) {
+                ++sig;
+                sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven);
+                exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
+            }
+            goto packReturn;
+        }
+        if (
+               (0x7FFE < exp)
+            || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))
+                    && doIncrement)
+        ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            roundMask = 0;
+ overflow:
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            if (
+                   roundNearEven
+                || (roundingMode == softfloat_round_near_maxMag)
+                || (roundingMode
+                        == (sign ? softfloat_round_min : softfloat_round_max))
+            ) {
+                exp = 0x7FFF;
+                sig = UINT64_C( 0x8000000000000000 );
+            } else {
+                exp = 0x7FFE;
+                sig = ~roundMask;
+            }
+            goto packReturn;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( sigExtra ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    if ( doIncrement ) {
+        ++sig;
+        if ( ! sig ) {
+            ++exp;
+            sig = UINT64_C( 0x8000000000000000 );
+        } else {
+            sig &= ~(uint64_t) (! (sigExtra & 0x7FFFFFFF) & roundNearEven);
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    zSPtr->signExp = packToExtF80UI64( sign, exp );
+    zSPtr->signif = sig;
+
+}
+
diff --git a/softfloat/source/s_roundPackMToF128M.c b/softfloat/source/s_roundPackMToF128M.c
index 22591b8..fad5d08 100644
--- a/softfloat/source/s_roundPackMToF128M.c
+++ b/softfloat/source/s_roundPackMToF128M.c
@@ -1,178 +1,178 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-void
- softfloat_roundPackMToF128M(
-     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint32_t sigExtra;
-    bool doIncrement, isTiny;
-    static const uint32_t maxSig[4] =
-        INIT_UINTM4( 0x0001FFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF );
-    uint32_t ui, uj;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    sigExtra = extSigPtr[indexWordLo( 5 )];
-    doIncrement = (0x80000000 <= sigExtra);
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        doIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                && sigExtra;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) exp ) {
-        if ( exp < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < -1)
-                || ! doIncrement
-                || (softfloat_compare128M(
-                        extSigPtr + indexMultiwordHi( 5, 4 ), maxSig )
-                        < 0);
-            softfloat_shiftRightJam160M( extSigPtr, -exp, extSigPtr );
-            exp = 0;
-            sigExtra = extSigPtr[indexWordLo( 5 )];
-            if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-            doIncrement = (0x80000000 <= sigExtra);
-            if (
-                   ! roundNearEven
-                && (roundingMode != softfloat_round_near_maxMag)
-            ) {
-                doIncrement =
-                    (roundingMode
-                         == (sign ? softfloat_round_min : softfloat_round_max))
-                        && sigExtra;
-            }
-        } else if (
-               (0x7FFD < exp)
-            || ((exp == 0x7FFD) && doIncrement
-                    && (softfloat_compare128M(
-                            extSigPtr + indexMultiwordHi( 5, 4 ), maxSig )
-                            == 0))
-        ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            if (
-                   roundNearEven
-                || (roundingMode == softfloat_round_near_maxMag)
-                || (roundingMode
-                        == (sign ? softfloat_round_min : softfloat_round_max))
-            ) {
-                ui = packToF128UI96( sign, 0x7FFF, 0 );
-                uj = 0;
-            } else {
-                ui = packToF128UI96( sign, 0x7FFE, 0x0000FFFF );
-                uj = 0xFFFFFFFF;
-            }
-            zWPtr[indexWordHi( 4 )] = ui;
-            zWPtr[indexWord( 4, 2 )] = uj;
-            zWPtr[indexWord( 4, 1 )] = uj;
-            zWPtr[indexWord( 4, 0 )] = uj;
-            return;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    uj = extSigPtr[indexWord( 5, 1 )];
-    if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            uj |= 1;
-            goto noIncrementPackReturn;
-        }
-#endif
-    }
-    if ( doIncrement ) {
-        ++uj;
-        if ( uj ) {
-            if ( ! (sigExtra & 0x7FFFFFFF) && roundNearEven ) uj &= ~1;
-            zWPtr[indexWord( 4, 2 )] = extSigPtr[indexWord( 5, 3 )];
-            zWPtr[indexWord( 4, 1 )] = extSigPtr[indexWord( 5, 2 )];
-            zWPtr[indexWord( 4, 0 )] = uj;
-            ui = extSigPtr[indexWordHi( 5 )];
-        } else {
-            zWPtr[indexWord( 4, 0 )] = uj;
-            ui = extSigPtr[indexWord( 5, 2 )] + 1;
-            zWPtr[indexWord( 4, 1 )] = ui;
-            uj = extSigPtr[indexWord( 5, 3 )];
-            if ( ui ) {
-                zWPtr[indexWord( 4, 2 )] = uj;
-                ui = extSigPtr[indexWordHi( 5 )];
-            } else {
-                ++uj;
-                zWPtr[indexWord( 4, 2 )] = uj;
-                ui = extSigPtr[indexWordHi( 5 )];
-                if ( ! uj ) ++ui;
-            }
-        }
-    } else {
- noIncrementPackReturn:
-        zWPtr[indexWord( 4, 0 )] = uj;
-        ui = extSigPtr[indexWord( 5, 2 )];
-        zWPtr[indexWord( 4, 1 )] = ui;
-        uj |= ui;
-        ui = extSigPtr[indexWord( 5, 3 )];
-        zWPtr[indexWord( 4, 2 )] = ui;
-        uj |= ui;
-        ui = extSigPtr[indexWordHi( 5 )];
-        uj |= ui;
-        if ( ! uj ) exp = 0;
-    }
-    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, ui );
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+void
+ softfloat_roundPackMToF128M(
+     bool sign, int32_t exp, uint32_t *extSigPtr, uint32_t *zWPtr )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint32_t sigExtra;
+    bool doIncrement, isTiny;
+    static const uint32_t maxSig[4] =
+        INIT_UINTM4( 0x0001FFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF );
+    uint32_t ui, uj;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    sigExtra = extSigPtr[indexWordLo( 5 )];
+    doIncrement = (0x80000000 <= sigExtra);
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        doIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                && sigExtra;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < -1)
+                || ! doIncrement
+                || (softfloat_compare128M(
+                        extSigPtr + indexMultiwordHi( 5, 4 ), maxSig )
+                        < 0);
+            softfloat_shiftRightJam160M( extSigPtr, -exp, extSigPtr );
+            exp = 0;
+            sigExtra = extSigPtr[indexWordLo( 5 )];
+            if ( isTiny && sigExtra ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+            doIncrement = (0x80000000 <= sigExtra);
+            if (
+                   ! roundNearEven
+                && (roundingMode != softfloat_round_near_maxMag)
+            ) {
+                doIncrement =
+                    (roundingMode
+                         == (sign ? softfloat_round_min : softfloat_round_max))
+                        && sigExtra;
+            }
+        } else if (
+               (0x7FFD < exp)
+            || ((exp == 0x7FFD) && doIncrement
+                    && (softfloat_compare128M(
+                            extSigPtr + indexMultiwordHi( 5, 4 ), maxSig )
+                            == 0))
+        ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            if (
+                   roundNearEven
+                || (roundingMode == softfloat_round_near_maxMag)
+                || (roundingMode
+                        == (sign ? softfloat_round_min : softfloat_round_max))
+            ) {
+                ui = packToF128UI96( sign, 0x7FFF, 0 );
+                uj = 0;
+            } else {
+                ui = packToF128UI96( sign, 0x7FFE, 0x0000FFFF );
+                uj = 0xFFFFFFFF;
+            }
+            zWPtr[indexWordHi( 4 )] = ui;
+            zWPtr[indexWord( 4, 2 )] = uj;
+            zWPtr[indexWord( 4, 1 )] = uj;
+            zWPtr[indexWord( 4, 0 )] = uj;
+            return;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    uj = extSigPtr[indexWord( 5, 1 )];
+    if ( sigExtra ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            uj |= 1;
+            goto noIncrementPackReturn;
+        }
+#endif
+    }
+    if ( doIncrement ) {
+        ++uj;
+        if ( uj ) {
+            if ( ! (sigExtra & 0x7FFFFFFF) && roundNearEven ) uj &= ~1;
+            zWPtr[indexWord( 4, 2 )] = extSigPtr[indexWord( 5, 3 )];
+            zWPtr[indexWord( 4, 1 )] = extSigPtr[indexWord( 5, 2 )];
+            zWPtr[indexWord( 4, 0 )] = uj;
+            ui = extSigPtr[indexWordHi( 5 )];
+        } else {
+            zWPtr[indexWord( 4, 0 )] = uj;
+            ui = extSigPtr[indexWord( 5, 2 )] + 1;
+            zWPtr[indexWord( 4, 1 )] = ui;
+            uj = extSigPtr[indexWord( 5, 3 )];
+            if ( ui ) {
+                zWPtr[indexWord( 4, 2 )] = uj;
+                ui = extSigPtr[indexWordHi( 5 )];
+            } else {
+                ++uj;
+                zWPtr[indexWord( 4, 2 )] = uj;
+                ui = extSigPtr[indexWordHi( 5 )];
+                if ( ! uj ) ++ui;
+            }
+        }
+    } else {
+ noIncrementPackReturn:
+        zWPtr[indexWord( 4, 0 )] = uj;
+        ui = extSigPtr[indexWord( 5, 2 )];
+        zWPtr[indexWord( 4, 1 )] = ui;
+        uj |= ui;
+        ui = extSigPtr[indexWord( 5, 3 )];
+        zWPtr[indexWord( 4, 2 )] = ui;
+        uj |= ui;
+        ui = extSigPtr[indexWordHi( 5 )];
+        uj |= ui;
+        if ( ! uj ) exp = 0;
+    }
+    zWPtr[indexWordHi( 4 )] = packToF128UI96( sign, exp, ui );
+
+}
+
diff --git a/softfloat/source/s_roundPackToBF16.c b/softfloat/source/s_roundPackToBF16.c
new file mode 100644
index 0000000..57a7ae4
--- /dev/null
+++ b/softfloat/source/s_roundPackToBF16.c
@@ -0,0 +1,114 @@
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+/** sig last significant bit is sig[7], the 7 LSBs will be used for rounding */
+bfloat16_t
+ softfloat_roundPackToBF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint_fast8_t roundIncrement, roundBits;
+    bool isTiny;
+    uint_fast16_t uiZ;
+    union ui16_bf16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    roundIncrement = 0x40;
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? 0x7F
+                : 0;
+    }
+    roundBits = sig & 0x7F;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0xFD <= (unsigned int) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                    || (exp < -1) || (sig + roundIncrement < 0x8000);
+            sig = softfloat_shiftRightJam32( sig, -exp );
+            exp = 0;
+            roundBits = sig & 0x7F;
+            if ( isTiny && roundBits ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+        } else if ( (0xFD < exp) || (0x8000 <= sig + roundIncrement) ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            uiZ = packToBF16UI( sign, 0xFF, 0 ) - ! roundIncrement;
+            goto uiZ;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig + roundIncrement)>>7;
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    sig &= ~(uint_fast16_t) (! (roundBits ^ 0x40) & roundNearEven);
+    if ( ! sig ) exp = 0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uiZ = packToBF16UI( sign, exp, sig );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundPackToExtF80.c b/softfloat/source/s_roundPackToExtF80.c
index 0cc7af9..a5ea38c 100644
--- a/softfloat/source/s_roundPackToExtF80.c
+++ b/softfloat/source/s_roundPackToExtF80.c
@@ -1,256 +1,256 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t
- softfloat_roundPackToExtF80(
-     bool sign,
-     int_fast32_t exp,
-     uint_fast64_t sig,
-     uint_fast64_t sigExtra,
-     uint_fast8_t roundingPrecision
- )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint_fast64_t roundIncrement, roundMask, roundBits;
-    bool isTiny, doIncrement;
-    struct uint64_extra sig64Extra;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    if ( roundingPrecision == 80 ) goto precision80;
-    if ( roundingPrecision == 64 ) {
-        roundIncrement = UINT64_C( 0x0000000000000400 );
-        roundMask = UINT64_C( 0x00000000000007FF );
-    } else if ( roundingPrecision == 32 ) {
-        roundIncrement = UINT64_C( 0x0000008000000000 );
-        roundMask = UINT64_C( 0x000000FFFFFFFFFF );
-    } else {
-        goto precision80;
-    }
-    sig |= (sigExtra != 0);
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        roundIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                ? roundMask
-                : 0;
-    }
-    roundBits = sig & roundMask;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
-        if ( exp <= 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < 0)
-                || (sig <= (uint64_t) (sig + roundIncrement));
-            sig = softfloat_shiftRightJam64( sig, 1 - exp );
-            roundBits = sig & roundMask;
-            if ( roundBits ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-                if ( roundingMode == softfloat_round_odd ) {
-                    sig |= roundMask + 1;
-                }
-#endif
-            }
-            sig += roundIncrement;
-            exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
-            roundIncrement = roundMask + 1;
-            if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
-                roundMask |= roundIncrement;
-            }
-            sig &= ~roundMask;
-            goto packReturn;
-        }
-        if (
-               (0x7FFE < exp)
-            || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))
-        ) {
-            goto overflow;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig = (sig & ~roundMask) | (roundMask + 1);
-            goto packReturn;
-        }
-#endif
-    }
-    sig = (uint64_t) (sig + roundIncrement);
-    if ( sig < roundIncrement ) {
-        ++exp;
-        sig = UINT64_C( 0x8000000000000000 );
-    }
-    roundIncrement = roundMask + 1;
-    if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
-        roundMask |= roundIncrement;
-    }
-    sig &= ~roundMask;
-    goto packReturn;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- precision80:
-    doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        doIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                && sigExtra;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
-        if ( exp <= 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < 0)
-                || ! doIncrement
-                || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));
-            sig64Extra =
-                softfloat_shiftRightJam64Extra( sig, sigExtra, 1 - exp );
-            exp = 0;
-            sig = sig64Extra.v;
-            sigExtra = sig64Extra.extra;
-            if ( sigExtra ) {
-                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
-                softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-                if ( roundingMode == softfloat_round_odd ) {
-                    sig |= 1;
-                    goto packReturn;
-                }
-#endif
-            }
-            doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
-            if (
-                ! roundNearEven
-                    && (roundingMode != softfloat_round_near_maxMag)
-            ) {
-                doIncrement =
-                    (roundingMode
-                         == (sign ? softfloat_round_min : softfloat_round_max))
-                        && sigExtra;
-            }
-            if ( doIncrement ) {
-                ++sig;
-                sig &=
-                    ~(uint_fast64_t)
-                         (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                              & roundNearEven);
-                exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
-            }
-            goto packReturn;
-        }
-        if (
-               (0x7FFE < exp)
-            || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))
-                    && doIncrement)
-        ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            roundMask = 0;
- overflow:
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            if (
-                   roundNearEven
-                || (roundingMode == softfloat_round_near_maxMag)
-                || (roundingMode
-                        == (sign ? softfloat_round_min : softfloat_round_max))
-            ) {
-                exp = 0x7FFF;
-                sig = UINT64_C( 0x8000000000000000 );
-            } else {
-                exp = 0x7FFE;
-                sig = ~roundMask;
-            }
-            goto packReturn;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    if ( doIncrement ) {
-        ++sig;
-        if ( ! sig ) {
-            ++exp;
-            sig = UINT64_C( 0x8000000000000000 );
-        } else {
-            sig &=
-                ~(uint_fast64_t)
-                     (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                          & roundNearEven);
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    uZ.s.signExp = packToExtF80UI64( sign, exp );
-    uZ.s.signif = sig;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t
+ softfloat_roundPackToExtF80(
+     bool sign,
+     int_fast32_t exp,
+     uint_fast64_t sig,
+     uint_fast64_t sigExtra,
+     uint_fast8_t roundingPrecision
+ )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint_fast64_t roundIncrement, roundMask, roundBits;
+    bool isTiny, doIncrement;
+    struct uint64_extra sig64Extra;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    if ( roundingPrecision == 80 ) goto precision80;
+    if ( roundingPrecision == 64 ) {
+        roundIncrement = UINT64_C( 0x0000000000000400 );
+        roundMask = UINT64_C( 0x00000000000007FF );
+    } else if ( roundingPrecision == 32 ) {
+        roundIncrement = UINT64_C( 0x0000008000000000 );
+        roundMask = UINT64_C( 0x000000FFFFFFFFFF );
+    } else {
+        goto precision80;
+    }
+    sig |= (sigExtra != 0);
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? roundMask
+                : 0;
+    }
+    roundBits = sig & roundMask;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
+        if ( exp <= 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < 0)
+                || (sig <= (uint64_t) (sig + roundIncrement));
+            sig = softfloat_shiftRightJam64( sig, 1 - exp );
+            roundBits = sig & roundMask;
+            if ( roundBits ) {
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+                if ( roundingMode == softfloat_round_odd ) {
+                    sig |= roundMask + 1;
+                }
+#endif
+            }
+            sig += roundIncrement;
+            exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
+            roundIncrement = roundMask + 1;
+            if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
+                roundMask |= roundIncrement;
+            }
+            sig &= ~roundMask;
+            goto packReturn;
+        }
+        if (
+               (0x7FFE < exp)
+            || ((exp == 0x7FFE) && ((uint64_t) (sig + roundIncrement) < sig))
+        ) {
+            goto overflow;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig = (sig & ~roundMask) | (roundMask + 1);
+            goto packReturn;
+        }
+#endif
+    }
+    sig = (uint64_t) (sig + roundIncrement);
+    if ( sig < roundIncrement ) {
+        ++exp;
+        sig = UINT64_C( 0x8000000000000000 );
+    }
+    roundIncrement = roundMask + 1;
+    if ( roundNearEven && (roundBits<<1 == roundIncrement) ) {
+        roundMask |= roundIncrement;
+    }
+    sig &= ~roundMask;
+    goto packReturn;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ precision80:
+    doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        doIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                && sigExtra;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) (exp - 1) ) {
+        if ( exp <= 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < 0)
+                || ! doIncrement
+                || (sig < UINT64_C( 0xFFFFFFFFFFFFFFFF ));
+            sig64Extra =
+                softfloat_shiftRightJam64Extra( sig, sigExtra, 1 - exp );
+            exp = 0;
+            sig = sig64Extra.v;
+            sigExtra = sig64Extra.extra;
+            if ( sigExtra ) {
+                if ( isTiny ) softfloat_raiseFlags( softfloat_flag_underflow );
+                softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+                if ( roundingMode == softfloat_round_odd ) {
+                    sig |= 1;
+                    goto packReturn;
+                }
+#endif
+            }
+            doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
+            if (
+                ! roundNearEven
+                    && (roundingMode != softfloat_round_near_maxMag)
+            ) {
+                doIncrement =
+                    (roundingMode
+                         == (sign ? softfloat_round_min : softfloat_round_max))
+                        && sigExtra;
+            }
+            if ( doIncrement ) {
+                ++sig;
+                sig &=
+                    ~(uint_fast64_t)
+                         (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                              & roundNearEven);
+                exp = ((sig & UINT64_C( 0x8000000000000000 )) != 0);
+            }
+            goto packReturn;
+        }
+        if (
+               (0x7FFE < exp)
+            || ((exp == 0x7FFE) && (sig == UINT64_C( 0xFFFFFFFFFFFFFFFF ))
+                    && doIncrement)
+        ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            roundMask = 0;
+ overflow:
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            if (
+                   roundNearEven
+                || (roundingMode == softfloat_round_near_maxMag)
+                || (roundingMode
+                        == (sign ? softfloat_round_min : softfloat_round_max))
+            ) {
+                exp = 0x7FFF;
+                sig = UINT64_C( 0x8000000000000000 );
+            } else {
+                exp = 0x7FFE;
+                sig = ~roundMask;
+            }
+            goto packReturn;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( sigExtra ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    if ( doIncrement ) {
+        ++sig;
+        if ( ! sig ) {
+            ++exp;
+            sig = UINT64_C( 0x8000000000000000 );
+        } else {
+            sig &=
+                ~(uint_fast64_t)
+                     (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                          & roundNearEven);
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uZ.s.signExp = packToExtF80UI64( sign, exp );
+    uZ.s.signif = sig;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundPackToF128.c b/softfloat/source/s_roundPackToF128.c
index 4158431..6688c52 100644
--- a/softfloat/source/s_roundPackToF128.c
+++ b/softfloat/source/s_roundPackToF128.c
@@ -1,171 +1,171 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t
- softfloat_roundPackToF128(
-     bool sign,
-     int_fast32_t exp,
-     uint_fast64_t sig64,
-     uint_fast64_t sig0,
-     uint_fast64_t sigExtra
- )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven, doIncrement, isTiny;
-    struct uint128_extra sig128Extra;
-    uint_fast64_t uiZ64, uiZ0;
-    struct uint128 sig128;
-    union ui128_f128 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        doIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                && sigExtra;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FFD <= (uint32_t) exp ) {
-        if ( exp < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                   (softfloat_detectTininess
-                        == softfloat_tininess_beforeRounding)
-                || (exp < -1)
-                || ! doIncrement
-                || softfloat_lt128(
-                       sig64,
-                       sig0,
-                       UINT64_C( 0x0001FFFFFFFFFFFF ),
-                       UINT64_C( 0xFFFFFFFFFFFFFFFF )
-                   );
-            sig128Extra =
-                softfloat_shiftRightJam128Extra( sig64, sig0, sigExtra, -exp );
-            sig64 = sig128Extra.v.v64;
-            sig0  = sig128Extra.v.v0;
-            sigExtra = sig128Extra.extra;
-            exp = 0;
-            if ( isTiny && sigExtra ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-            doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
-            if (
-                   ! roundNearEven
-                && (roundingMode != softfloat_round_near_maxMag)
-            ) {
-                doIncrement =
-                    (roundingMode
-                         == (sign ? softfloat_round_min : softfloat_round_max))
-                        && sigExtra;
-            }
-        } else if (
-               (0x7FFD < exp)
-            || ((exp == 0x7FFD)
-                    && softfloat_eq128( 
-                           sig64,
-                           sig0,
-                           UINT64_C( 0x0001FFFFFFFFFFFF ),
-                           UINT64_C( 0xFFFFFFFFFFFFFFFF )
-                       )
-                    && doIncrement)
-        ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            if (
-                   roundNearEven
-                || (roundingMode == softfloat_round_near_maxMag)
-                || (roundingMode
-                        == (sign ? softfloat_round_min : softfloat_round_max))
-            ) {
-                uiZ64 = packToF128UI64( sign, 0x7FFF, 0 );
-                uiZ0  = 0;
-            } else {
-                uiZ64 =
-                    packToF128UI64(
-                        sign, 0x7FFE, UINT64_C( 0x0000FFFFFFFFFFFF ) );
-                uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF );
-            }
-            goto uiZ;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( sigExtra ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig0 |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    if ( doIncrement ) {
-        sig128 = softfloat_add128( sig64, sig0, 0, 1 );
-        sig64 = sig128.v64;
-        sig0 =
-            sig128.v0
-                & ~(uint64_t)
-                       (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
-                            & roundNearEven);
-    } else {
-        if ( ! (sig64 | sig0) ) exp = 0;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    uiZ64 = packToF128UI64( sign, exp, sig64 );
-    uiZ0  = sig0;
- uiZ:
-    uZ.ui.v64 = uiZ64;
-    uZ.ui.v0  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t
+ softfloat_roundPackToF128(
+     bool sign,
+     int_fast32_t exp,
+     uint_fast64_t sig64,
+     uint_fast64_t sig0,
+     uint_fast64_t sigExtra
+ )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven, doIncrement, isTiny;
+    struct uint128_extra sig128Extra;
+    uint_fast64_t uiZ64, uiZ0;
+    struct uint128 sig128;
+    union ui128_f128 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        doIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                && sigExtra;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FFD <= (uint32_t) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                   (softfloat_detectTininess
+                        == softfloat_tininess_beforeRounding)
+                || (exp < -1)
+                || ! doIncrement
+                || softfloat_lt128(
+                       sig64,
+                       sig0,
+                       UINT64_C( 0x0001FFFFFFFFFFFF ),
+                       UINT64_C( 0xFFFFFFFFFFFFFFFF )
+                   );
+            sig128Extra =
+                softfloat_shiftRightJam128Extra( sig64, sig0, sigExtra, -exp );
+            sig64 = sig128Extra.v.v64;
+            sig0  = sig128Extra.v.v0;
+            sigExtra = sig128Extra.extra;
+            exp = 0;
+            if ( isTiny && sigExtra ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+            doIncrement = (UINT64_C( 0x8000000000000000 ) <= sigExtra);
+            if (
+                   ! roundNearEven
+                && (roundingMode != softfloat_round_near_maxMag)
+            ) {
+                doIncrement =
+                    (roundingMode
+                         == (sign ? softfloat_round_min : softfloat_round_max))
+                        && sigExtra;
+            }
+        } else if (
+               (0x7FFD < exp)
+            || ((exp == 0x7FFD)
+                    && softfloat_eq128( 
+                           sig64,
+                           sig0,
+                           UINT64_C( 0x0001FFFFFFFFFFFF ),
+                           UINT64_C( 0xFFFFFFFFFFFFFFFF )
+                       )
+                    && doIncrement)
+        ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            if (
+                   roundNearEven
+                || (roundingMode == softfloat_round_near_maxMag)
+                || (roundingMode
+                        == (sign ? softfloat_round_min : softfloat_round_max))
+            ) {
+                uiZ64 = packToF128UI64( sign, 0x7FFF, 0 );
+                uiZ0  = 0;
+            } else {
+                uiZ64 =
+                    packToF128UI64(
+                        sign, 0x7FFE, UINT64_C( 0x0000FFFFFFFFFFFF ) );
+                uiZ0 = UINT64_C( 0xFFFFFFFFFFFFFFFF );
+            }
+            goto uiZ;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( sigExtra ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig0 |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    if ( doIncrement ) {
+        sig128 = softfloat_add128( sig64, sig0, 0, 1 );
+        sig64 = sig128.v64;
+        sig0 =
+            sig128.v0
+                & ~(uint64_t)
+                       (! (sigExtra & UINT64_C( 0x7FFFFFFFFFFFFFFF ))
+                            & roundNearEven);
+    } else {
+        if ( ! (sig64 | sig0) ) exp = 0;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uiZ64 = packToF128UI64( sign, exp, sig64 );
+    uiZ0  = sig0;
+ uiZ:
+    uZ.ui.v64 = uiZ64;
+    uZ.ui.v0  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundPackToF16.c b/softfloat/source/s_roundPackToF16.c
index 2dde55b..8d03d3b 100644
--- a/softfloat/source/s_roundPackToF16.c
+++ b/softfloat/source/s_roundPackToF16.c
@@ -1,113 +1,113 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t
- softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint_fast8_t roundIncrement, roundBits;
-    bool isTiny;
-    uint_fast16_t uiZ;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    roundIncrement = 0x8;
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        roundIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                ? 0xF
-                : 0;
-    }
-    roundBits = sig & 0xF;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x1D <= (unsigned int) exp ) {
-        if ( exp < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
-                    || (exp < -1) || (sig + roundIncrement < 0x8000);
-            sig = softfloat_shiftRightJam32( sig, -exp );
-            exp = 0;
-            roundBits = sig & 0xF;
-            if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-        } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;
-            goto uiZ;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = (sig + roundIncrement)>>4;
-    if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    sig &= ~(uint_fast16_t) (! (roundBits ^ 8) & roundNearEven);
-    if ( ! sig ) exp = 0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    uiZ = packToF16UI( sign, exp, sig );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t
+ softfloat_roundPackToF16( bool sign, int_fast16_t exp, uint_fast16_t sig )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint_fast8_t roundIncrement, roundBits;
+    bool isTiny;
+    uint_fast16_t uiZ;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    roundIncrement = 0x8;
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? 0xF
+                : 0;
+    }
+    roundBits = sig & 0xF;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x1D <= (unsigned int) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                    || (exp < -1) || (sig + roundIncrement < 0x8000);
+            sig = softfloat_shiftRightJam32( sig, -exp );
+            exp = 0;
+            roundBits = sig & 0xF;
+            if ( isTiny && roundBits ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+        } else if ( (0x1D < exp) || (0x8000 <= sig + roundIncrement) ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            uiZ = packToF16UI( sign, 0x1F, 0 ) - ! roundIncrement;
+            goto uiZ;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig + roundIncrement)>>4;
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    sig &= ~(uint_fast16_t) (! (roundBits ^ 8) & roundNearEven);
+    if ( ! sig ) exp = 0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uiZ = packToF16UI( sign, exp, sig );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundPackToF32.c b/softfloat/source/s_roundPackToF32.c
index a69b8d4..f1eb0c2 100644
--- a/softfloat/source/s_roundPackToF32.c
+++ b/softfloat/source/s_roundPackToF32.c
@@ -1,113 +1,113 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t
- softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint_fast8_t roundIncrement, roundBits;
-    bool isTiny;
-    uint_fast32_t uiZ;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    roundIncrement = 0x40;
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        roundIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                ? 0x7F
-                : 0;
-    }
-    roundBits = sig & 0x7F;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0xFD <= (unsigned int) exp ) {
-        if ( exp < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
-                    || (exp < -1) || (sig + roundIncrement < 0x80000000);
-            sig = softfloat_shiftRightJam32( sig, -exp );
-            exp = 0;
-            roundBits = sig & 0x7F;
-            if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-        } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
-            goto uiZ;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = (sig + roundIncrement)>>7;
-    if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    sig &= ~(uint_fast32_t) (! (roundBits ^ 0x40) & roundNearEven);
-    if ( ! sig ) exp = 0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    uiZ = packToF32UI( sign, exp, sig );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t
+ softfloat_roundPackToF32( bool sign, int_fast16_t exp, uint_fast32_t sig )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint_fast8_t roundIncrement, roundBits;
+    bool isTiny;
+    uint_fast32_t uiZ;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    roundIncrement = 0x40;
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? 0x7F
+                : 0;
+    }
+    roundBits = sig & 0x7F;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0xFD <= (unsigned int) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                    || (exp < -1) || (sig + roundIncrement < 0x80000000);
+            sig = softfloat_shiftRightJam32( sig, -exp );
+            exp = 0;
+            roundBits = sig & 0x7F;
+            if ( isTiny && roundBits ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+        } else if ( (0xFD < exp) || (0x80000000 <= sig + roundIncrement) ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            uiZ = packToF32UI( sign, 0xFF, 0 ) - ! roundIncrement;
+            goto uiZ;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig + roundIncrement)>>7;
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    sig &= ~(uint_fast32_t) (! (roundBits ^ 0x40) & roundNearEven);
+    if ( ! sig ) exp = 0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uiZ = packToF32UI( sign, exp, sig );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundPackToF64.c b/softfloat/source/s_roundPackToF64.c
index f7f3abf..98c1639 100644
--- a/softfloat/source/s_roundPackToF64.c
+++ b/softfloat/source/s_roundPackToF64.c
@@ -1,117 +1,117 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t
- softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
-{
-    uint_fast8_t roundingMode;
-    bool roundNearEven;
-    uint_fast16_t roundIncrement, roundBits;
-    bool isTiny;
-    uint_fast64_t uiZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundingMode = softfloat_roundingMode;
-    roundNearEven = (roundingMode == softfloat_round_near_even);
-    roundIncrement = 0x200;
-    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
-        roundIncrement =
-            (roundingMode
-                 == (sign ? softfloat_round_min : softfloat_round_max))
-                ? 0x3FF
-                : 0;
-    }
-    roundBits = sig & 0x3FF;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if ( 0x7FD <= (uint16_t) exp ) {
-        if ( exp < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            isTiny =
-                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
-                    || (exp < -1)
-                    || (sig + roundIncrement < UINT64_C( 0x8000000000000000 ));
-            sig = softfloat_shiftRightJam64( sig, -exp );
-            exp = 0;
-            roundBits = sig & 0x3FF;
-            if ( isTiny && roundBits ) {
-                softfloat_raiseFlags( softfloat_flag_underflow );
-            }
-        } else if (
-            (0x7FD < exp)
-                || (UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement)
-        ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            softfloat_raiseFlags(
-                softfloat_flag_overflow | softfloat_flag_inexact );
-            uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
-            goto uiZ;
-        }
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    sig = (sig + roundIncrement)>>10;
-    if ( roundBits ) {
-        softfloat_exceptionFlags |= softfloat_flag_inexact;
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) {
-            sig |= 1;
-            goto packReturn;
-        }
-#endif
-    }
-    sig &= ~(uint_fast64_t) (! (roundBits ^ 0x200) & roundNearEven);
-    if ( ! sig ) exp = 0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- packReturn:
-    uiZ = packToF64UI( sign, exp, sig );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2017 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t
+ softfloat_roundPackToF64( bool sign, int_fast16_t exp, uint_fast64_t sig )
+{
+    uint_fast8_t roundingMode;
+    bool roundNearEven;
+    uint_fast16_t roundIncrement, roundBits;
+    bool isTiny;
+    uint_fast64_t uiZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundingMode = softfloat_roundingMode;
+    roundNearEven = (roundingMode == softfloat_round_near_even);
+    roundIncrement = 0x200;
+    if ( ! roundNearEven && (roundingMode != softfloat_round_near_maxMag) ) {
+        roundIncrement =
+            (roundingMode
+                 == (sign ? softfloat_round_min : softfloat_round_max))
+                ? 0x3FF
+                : 0;
+    }
+    roundBits = sig & 0x3FF;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if ( 0x7FD <= (uint16_t) exp ) {
+        if ( exp < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            isTiny =
+                (softfloat_detectTininess == softfloat_tininess_beforeRounding)
+                    || (exp < -1)
+                    || (sig + roundIncrement < UINT64_C( 0x8000000000000000 ));
+            sig = softfloat_shiftRightJam64( sig, -exp );
+            exp = 0;
+            roundBits = sig & 0x3FF;
+            if ( isTiny && roundBits ) {
+                softfloat_raiseFlags( softfloat_flag_underflow );
+            }
+        } else if (
+            (0x7FD < exp)
+                || (UINT64_C( 0x8000000000000000 ) <= sig + roundIncrement)
+        ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            softfloat_raiseFlags(
+                softfloat_flag_overflow | softfloat_flag_inexact );
+            uiZ = packToF64UI( sign, 0x7FF, 0 ) - ! roundIncrement;
+            goto uiZ;
+        }
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    sig = (sig + roundIncrement)>>10;
+    if ( roundBits ) {
+        softfloat_exceptionFlags |= softfloat_flag_inexact;
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) {
+            sig |= 1;
+            goto packReturn;
+        }
+#endif
+    }
+    sig &= ~(uint_fast64_t) (! (roundBits ^ 0x200) & roundNearEven);
+    if ( ! sig ) exp = 0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ packReturn:
+    uiZ = packToF64UI( sign, exp, sig );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_roundToI32.c b/softfloat/source/s_roundToI32.c
index a3e727d..1999dcf 100644
--- a/softfloat/source/s_roundToI32.c
+++ b/softfloat/source/s_roundToI32.c
@@ -1,98 +1,98 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast32_t
- softfloat_roundToI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
-{
-    uint_fast16_t roundIncrement, roundBits;
-    uint_fast32_t sig32;
-    union { uint32_t ui; int32_t i; } uZ;
-    int_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundIncrement = 0x800;
-    if (
-        (roundingMode != softfloat_round_near_maxMag)
-            && (roundingMode != softfloat_round_near_even)
-    ) {
-        roundIncrement = 0;
-        if ( 
-            sign
-                ? (roundingMode == softfloat_round_min)
-#ifdef SOFTFLOAT_ROUND_ODD
-                      || (roundingMode == softfloat_round_odd)
-#endif
-                : (roundingMode == softfloat_round_max)
-        ) {
-            roundIncrement = 0xFFF;
-        }
-    }
-    roundBits = sig & 0xFFF;
-    sig += roundIncrement;
-    if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;
-    sig32 = sig>>12;
-    if (
-        (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)
-    ) {
-        sig32 &= ~(uint_fast32_t) 1;
-    }
-    uZ.ui = sign ? -sig32 : sig32;
-    z = uZ.i;
-    if ( z && ((z < 0) ^ sign) ) goto invalid;
-    if ( roundBits ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) z |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? i32_fromNegOverflow : i32_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast32_t
+ softfloat_roundToI32(
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+{
+    uint_fast16_t roundIncrement, roundBits;
+    uint_fast32_t sig32;
+    union { uint32_t ui; int32_t i; } uZ;
+    int_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundIncrement = 0x800;
+    if (
+        (roundingMode != softfloat_round_near_maxMag)
+            && (roundingMode != softfloat_round_near_even)
+    ) {
+        roundIncrement = 0;
+        if ( 
+            sign
+                ? (roundingMode == softfloat_round_min)
+#ifdef SOFTFLOAT_ROUND_ODD
+                      || (roundingMode == softfloat_round_odd)
+#endif
+                : (roundingMode == softfloat_round_max)
+        ) {
+            roundIncrement = 0xFFF;
+        }
+    }
+    roundBits = sig & 0xFFF;
+    sig += roundIncrement;
+    if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;
+    sig32 = sig>>12;
+    if (
+        (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)
+    ) {
+        sig32 &= ~(uint_fast32_t) 1;
+    }
+    uZ.ui = sign ? -sig32 : sig32;
+    z = uZ.i;
+    if ( z && ((z < 0) ^ sign) ) goto invalid;
+    if ( roundBits ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) z |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? i32_fromNegOverflow : i32_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_roundToI64.c b/softfloat/source/s_roundToI64.c
index 773c82c..d1e9d27 100644
--- a/softfloat/source/s_roundToI64.c
+++ b/softfloat/source/s_roundToI64.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-int_fast64_t
- softfloat_roundToI64(
-     bool sign,
-     uint_fast64_t sig,
-     uint_fast64_t sigExtra,
-     uint_fast8_t roundingMode,
-     bool exact
- )
-{
-    union { uint64_t ui; int64_t i; } uZ;
-    int_fast64_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if (
-        (roundingMode == softfloat_round_near_maxMag)
-            || (roundingMode == softfloat_round_near_even)
-    ) {
-        if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;
-    } else {
-        if (
-            sigExtra
-                && (sign
-                        ? (roundingMode == softfloat_round_min)
-#ifdef SOFTFLOAT_ROUND_ODD
-                              || (roundingMode == softfloat_round_odd)
-#endif
-                        : (roundingMode == softfloat_round_max))
-        ) {
- increment:
-            ++sig;
-            if ( !sig ) goto invalid;
-            if (
-                (sigExtra == UINT64_C( 0x8000000000000000 ))
-                    && (roundingMode == softfloat_round_near_even)
-            ) {
-                sig &= ~(uint_fast64_t) 1;
-            }
-        }
-    }
-    uZ.ui = sign ? -sig : sig;
-    z = uZ.i;
-    if ( z && ((z < 0) ^ sign) ) goto invalid;
-    if ( sigExtra ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) z |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+int_fast64_t
+ softfloat_roundToI64(
+     bool sign,
+     uint_fast64_t sig,
+     uint_fast64_t sigExtra,
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+    union { uint64_t ui; int64_t i; } uZ;
+    int_fast64_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if (
+        (roundingMode == softfloat_round_near_maxMag)
+            || (roundingMode == softfloat_round_near_even)
+    ) {
+        if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;
+    } else {
+        if (
+            sigExtra
+                && (sign
+                        ? (roundingMode == softfloat_round_min)
+#ifdef SOFTFLOAT_ROUND_ODD
+                              || (roundingMode == softfloat_round_odd)
+#endif
+                        : (roundingMode == softfloat_round_max))
+        ) {
+ increment:
+            ++sig;
+            if ( !sig ) goto invalid;
+            if (
+                (sigExtra == UINT64_C( 0x8000000000000000 ))
+                    && (roundingMode == softfloat_round_near_even)
+            ) {
+                sig &= ~(uint_fast64_t) 1;
+            }
+        }
+    }
+    uZ.ui = sign ? -sig : sig;
+    z = uZ.i;
+    if ( z && ((z < 0) ^ sign) ) goto invalid;
+    if ( sigExtra ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) z |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? i64_fromNegOverflow : i64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_roundToUI32.c b/softfloat/source/s_roundToUI32.c
index 059e231..eaad69e 100644
--- a/softfloat/source/s_roundToUI32.c
+++ b/softfloat/source/s_roundToUI32.c
@@ -1,93 +1,93 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast32_t
- softfloat_roundToUI32(
-     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
-{
-    uint_fast16_t roundIncrement, roundBits;
-    uint_fast32_t z;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    roundIncrement = 0x800;
-    if ( 
-        (roundingMode != softfloat_round_near_maxMag) 
-            && (roundingMode != softfloat_round_near_even)
-    ) {
-        roundIncrement = 0;
-        if ( sign ) {
-            if ( !sig ) return 0;
-            if ( roundingMode == softfloat_round_min ) goto invalid;
-#ifdef SOFTFLOAT_ROUND_ODD
-            if ( roundingMode == softfloat_round_odd ) goto invalid;
-#endif
-        } else {
-            if ( roundingMode == softfloat_round_max ) roundIncrement = 0xFFF;
-        }
-    }
-    roundBits = sig & 0xFFF;
-    sig += roundIncrement;
-    if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;
-    z = sig>>12;
-    if ( 
-        (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)
-    ) {
-        z &= ~(uint_fast32_t) 1;
-    }
-    if ( sign && z ) goto invalid;
-    if ( roundBits ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) z |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return z;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast32_t
+ softfloat_roundToUI32(
+     bool sign, uint_fast64_t sig, uint_fast8_t roundingMode, bool exact )
+{
+    uint_fast16_t roundIncrement, roundBits;
+    uint_fast32_t z;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    roundIncrement = 0x800;
+    if ( 
+        (roundingMode != softfloat_round_near_maxMag) 
+            && (roundingMode != softfloat_round_near_even)
+    ) {
+        roundIncrement = 0;
+        if ( sign ) {
+            if ( !sig ) return 0;
+            if ( roundingMode == softfloat_round_min ) goto invalid;
+#ifdef SOFTFLOAT_ROUND_ODD
+            if ( roundingMode == softfloat_round_odd ) goto invalid;
+#endif
+        } else {
+            if ( roundingMode == softfloat_round_max ) roundIncrement = 0xFFF;
+        }
+    }
+    roundBits = sig & 0xFFF;
+    sig += roundIncrement;
+    if ( sig & UINT64_C( 0xFFFFF00000000000 ) ) goto invalid;
+    z = sig>>12;
+    if ( 
+        (roundBits == 0x800) && (roundingMode == softfloat_round_near_even)
+    ) {
+        z &= ~(uint_fast32_t) 1;
+    }
+    if ( sign && z ) goto invalid;
+    if ( roundBits ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) z |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return z;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? ui32_fromNegOverflow : ui32_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_roundToUI64.c b/softfloat/source/s_roundToUI64.c
index 856ad97..0ba78a6 100644
--- a/softfloat/source/s_roundToUI64.c
+++ b/softfloat/source/s_roundToUI64.c
@@ -1,97 +1,97 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-uint_fast64_t
- softfloat_roundToUI64(
-     bool sign,
-     uint_fast64_t sig,
-     uint_fast64_t sigExtra,
-     uint_fast8_t roundingMode,
-     bool exact
- )
-{
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    if (
-        (roundingMode == softfloat_round_near_maxMag)
-            || (roundingMode == softfloat_round_near_even)
-    ) {
-        if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;
-    } else {
-        if ( sign ) {
-            if ( !(sig | sigExtra) ) return 0;
-            if ( roundingMode == softfloat_round_min ) goto invalid;
-#ifdef SOFTFLOAT_ROUND_ODD
-            if ( roundingMode == softfloat_round_odd ) goto invalid;
-#endif
-        } else {
-            if ( (roundingMode == softfloat_round_max) && sigExtra ) {
- increment:
-                ++sig;
-                if ( !sig ) goto invalid;
-                if ( 
-                    (sigExtra == UINT64_C( 0x8000000000000000 ))
-                        && (roundingMode == softfloat_round_near_even)
-                ) {
-                    sig &= ~(uint_fast64_t) 1;
-                }
-            }
-        }
-    }
-    if ( sign && sig ) goto invalid;
-    if ( sigExtra ) {
-#ifdef SOFTFLOAT_ROUND_ODD
-        if ( roundingMode == softfloat_round_odd ) sig |= 1;
-#endif
-        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
-    }
-    return sig;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- invalid:
-    softfloat_raiseFlags( softfloat_flag_invalid );
-    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+uint_fast64_t
+ softfloat_roundToUI64(
+     bool sign,
+     uint_fast64_t sig,
+     uint_fast64_t sigExtra,
+     uint_fast8_t roundingMode,
+     bool exact
+ )
+{
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    if (
+        (roundingMode == softfloat_round_near_maxMag)
+            || (roundingMode == softfloat_round_near_even)
+    ) {
+        if ( UINT64_C( 0x8000000000000000 ) <= sigExtra ) goto increment;
+    } else {
+        if ( sign ) {
+            if ( !(sig | sigExtra) ) return 0;
+            if ( roundingMode == softfloat_round_min ) goto invalid;
+#ifdef SOFTFLOAT_ROUND_ODD
+            if ( roundingMode == softfloat_round_odd ) goto invalid;
+#endif
+        } else {
+            if ( (roundingMode == softfloat_round_max) && sigExtra ) {
+ increment:
+                ++sig;
+                if ( !sig ) goto invalid;
+                if ( 
+                    (sigExtra == UINT64_C( 0x8000000000000000 ))
+                        && (roundingMode == softfloat_round_near_even)
+                ) {
+                    sig &= ~(uint_fast64_t) 1;
+                }
+            }
+        }
+    }
+    if ( sign && sig ) goto invalid;
+    if ( sigExtra ) {
+#ifdef SOFTFLOAT_ROUND_ODD
+        if ( roundingMode == softfloat_round_odd ) sig |= 1;
+#endif
+        if ( exact ) softfloat_exceptionFlags |= softfloat_flag_inexact;
+    }
+    return sig;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ invalid:
+    softfloat_raiseFlags( softfloat_flag_invalid );
+    return sign ? ui64_fromNegOverflow : ui64_fromPosOverflow;
+
+}
+
diff --git a/softfloat/source/s_shiftLeftM.c b/softfloat/source/s_shiftLeftM.c
index 71a3099..feafc67 100644
--- a/softfloat/source/s_shiftLeftM.c
+++ b/softfloat/source/s_shiftLeftM.c
@@ -1,91 +1,91 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shiftLeftM
-
-#define softfloat_shiftLeftM softfloat_shiftLeftM
-#include "primitives.h"
-
-void
- softfloat_shiftLeftM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- )
-{
-    uint32_t wordDist;
-    uint_fast8_t innerDist;
-    uint32_t *destPtr;
-    uint_fast8_t i;
-
-    wordDist = dist>>5;
-    if ( wordDist < size_words ) {
-        aPtr += indexMultiwordLoBut( size_words, wordDist );
-        innerDist = dist & 31;
-        if ( innerDist ) {
-            softfloat_shortShiftLeftM(
-                size_words - wordDist,
-                aPtr,
-                innerDist,
-                zPtr + indexMultiwordHiBut( size_words, wordDist )
-            );
-            if ( ! wordDist ) return;
-        } else {
-            aPtr += indexWordHi( size_words - wordDist );
-            destPtr = zPtr + indexWordHi( size_words );
-            for ( i = size_words - wordDist; i; --i ) {
-                *destPtr = *aPtr;
-                aPtr -= wordIncr;
-                destPtr -= wordIncr;
-            }
-        }
-        zPtr += indexMultiwordLo( size_words, wordDist );
-    } else {
-        wordDist = size_words;
-    }
-    do {
-        *zPtr++ = 0;
-        --wordDist;
-    } while ( wordDist );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shiftLeftM
+
+#define softfloat_shiftLeftM softfloat_shiftLeftM
+#include "primitives.h"
+
+void
+ softfloat_shiftLeftM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint32_t wordDist;
+    uint_fast8_t innerDist;
+    uint32_t *destPtr;
+    uint_fast8_t i;
+
+    wordDist = dist>>5;
+    if ( wordDist < size_words ) {
+        aPtr += indexMultiwordLoBut( size_words, wordDist );
+        innerDist = dist & 31;
+        if ( innerDist ) {
+            softfloat_shortShiftLeftM(
+                size_words - wordDist,
+                aPtr,
+                innerDist,
+                zPtr + indexMultiwordHiBut( size_words, wordDist )
+            );
+            if ( ! wordDist ) return;
+        } else {
+            aPtr += indexWordHi( size_words - wordDist );
+            destPtr = zPtr + indexWordHi( size_words );
+            for ( i = size_words - wordDist; i; --i ) {
+                *destPtr = *aPtr;
+                aPtr -= wordIncr;
+                destPtr -= wordIncr;
+            }
+        }
+        zPtr += indexMultiwordLo( size_words, wordDist );
+    } else {
+        wordDist = size_words;
+    }
+    do {
+        *zPtr++ = 0;
+        --wordDist;
+    } while ( wordDist );
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftNormSigF128M.c b/softfloat/source/s_shiftNormSigF128M.c
index fa4976c..4820f39 100644
--- a/softfloat/source/s_shiftNormSigF128M.c
+++ b/softfloat/source/s_shiftNormSigF128M.c
@@ -1,78 +1,78 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-
-int
- softfloat_shiftNormSigF128M(
-     const uint32_t *wPtr, uint_fast8_t shiftDist, uint32_t *sigPtr )
-{
-    uint32_t wordSig;
-    int32_t exp;
-    uint32_t leadingBit;
-
-    wordSig = wPtr[indexWordHi( 4 )];
-    exp = expF128UI96( wordSig );
-    if ( exp ) {
-        softfloat_shortShiftLeft128M( wPtr, shiftDist, sigPtr );
-        leadingBit = 0x00010000<<shiftDist;
-        sigPtr[indexWordHi( 4 )] =
-            (sigPtr[indexWordHi( 4 )] & (leadingBit - 1)) | leadingBit;
-    } else {
-        exp = 16;
-        wordSig &= 0x7FFFFFFF;
-        if ( ! wordSig ) {
-            exp = -16;
-            wordSig = wPtr[indexWord( 4, 2 )];
-            if ( ! wordSig ) {
-                exp = -48;
-                wordSig = wPtr[indexWord( 4, 1 )];
-                if ( ! wordSig ) {
-                    wordSig = wPtr[indexWord( 4, 0 )];
-                    if ( ! wordSig ) return -128;
-                    exp = -80;
-                }
-            }
-        }
-        exp -= softfloat_countLeadingZeros32( wordSig );
-        softfloat_shiftLeft128M( wPtr, 1 - exp + shiftDist, sigPtr );
-    }
-    return exp;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+
+int
+ softfloat_shiftNormSigF128M(
+     const uint32_t *wPtr, uint_fast8_t shiftDist, uint32_t *sigPtr )
+{
+    uint32_t wordSig;
+    int32_t exp;
+    uint32_t leadingBit;
+
+    wordSig = wPtr[indexWordHi( 4 )];
+    exp = expF128UI96( wordSig );
+    if ( exp ) {
+        softfloat_shortShiftLeft128M( wPtr, shiftDist, sigPtr );
+        leadingBit = 0x00010000<<shiftDist;
+        sigPtr[indexWordHi( 4 )] =
+            (sigPtr[indexWordHi( 4 )] & (leadingBit - 1)) | leadingBit;
+    } else {
+        exp = 16;
+        wordSig &= 0x7FFFFFFF;
+        if ( ! wordSig ) {
+            exp = -16;
+            wordSig = wPtr[indexWord( 4, 2 )];
+            if ( ! wordSig ) {
+                exp = -48;
+                wordSig = wPtr[indexWord( 4, 1 )];
+                if ( ! wordSig ) {
+                    wordSig = wPtr[indexWord( 4, 0 )];
+                    if ( ! wordSig ) return -128;
+                    exp = -80;
+                }
+            }
+        }
+        exp -= softfloat_countLeadingZeros32( wordSig );
+        softfloat_shiftLeft128M( wPtr, 1 - exp + shiftDist, sigPtr );
+    }
+    return exp;
+
+}
+
diff --git a/softfloat/source/s_shiftRightJam128.c b/softfloat/source/s_shiftRightJam128.c
index aac5f6d..633e112 100644
--- a/softfloat/source/s_shiftRightJam128.c
+++ b/softfloat/source/s_shiftRightJam128.c
@@ -1,69 +1,69 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shiftRightJam128
-
-struct uint128
- softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist )
-{
-    uint_fast8_t u8NegDist;
-    struct uint128 z;
-
-    if ( dist < 64 ) {
-        u8NegDist = -dist;
-        z.v64 = a64>>dist;
-        z.v0 =
-            a64<<(u8NegDist & 63) | a0>>dist
-                | ((uint64_t) (a0<<(u8NegDist & 63)) != 0);
-    } else {
-        z.v64 = 0;
-        z.v0 =
-            (dist < 127)
-                ? a64>>(dist & 63)
-                      | (((a64 & (((uint_fast64_t) 1<<(dist & 63)) - 1)) | a0)
-                             != 0)
-                : ((a64 | a0) != 0);
-    }
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shiftRightJam128
+
+struct uint128
+ softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist )
+{
+    uint_fast8_t u8NegDist;
+    struct uint128 z;
+
+    if ( dist < 64 ) {
+        u8NegDist = -dist;
+        z.v64 = a64>>dist;
+        z.v0 =
+            a64<<(u8NegDist & 63) | a0>>dist
+                | ((uint64_t) (a0<<(u8NegDist & 63)) != 0);
+    } else {
+        z.v64 = 0;
+        z.v0 =
+            (dist < 127)
+                ? a64>>(dist & 63)
+                      | (((a64 & (((uint_fast64_t) 1<<(dist & 63)) - 1)) | a0)
+                             != 0)
+                : ((a64 | a0) != 0);
+    }
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJam128Extra.c b/softfloat/source/s_shiftRightJam128Extra.c
index 7572288..efdfc54 100644
--- a/softfloat/source/s_shiftRightJam128Extra.c
+++ b/softfloat/source/s_shiftRightJam128Extra.c
@@ -1,77 +1,77 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shiftRightJam128Extra
-
-struct uint128_extra
- softfloat_shiftRightJam128Extra(
-     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist )
-{
-    uint_fast8_t u8NegDist;
-    struct uint128_extra z;
-
-    u8NegDist = -dist;
-    if ( dist < 64 ) {
-        z.v.v64 = a64>>dist;
-        z.v.v0 = a64<<(u8NegDist & 63) | a0>>dist;
-        z.extra = a0<<(u8NegDist & 63);
-    } else {
-        z.v.v64 = 0;
-        if ( dist == 64 ) {
-            z.v.v0 = a64;
-            z.extra = a0;
-        } else {
-            extra |= a0;
-            if ( dist < 128 ) {
-                z.v.v0 = a64>>(dist & 63);
-                z.extra = a64<<(u8NegDist & 63);
-            } else {
-                z.v.v0 = 0;
-                z.extra = (dist == 128) ? a64 : (a64 != 0);
-            }
-        }
-    }
-    z.extra |= (extra != 0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shiftRightJam128Extra
+
+struct uint128_extra
+ softfloat_shiftRightJam128Extra(
+     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist )
+{
+    uint_fast8_t u8NegDist;
+    struct uint128_extra z;
+
+    u8NegDist = -dist;
+    if ( dist < 64 ) {
+        z.v.v64 = a64>>dist;
+        z.v.v0 = a64<<(u8NegDist & 63) | a0>>dist;
+        z.extra = a0<<(u8NegDist & 63);
+    } else {
+        z.v.v64 = 0;
+        if ( dist == 64 ) {
+            z.v.v0 = a64;
+            z.extra = a0;
+        } else {
+            extra |= a0;
+            if ( dist < 128 ) {
+                z.v.v0 = a64>>(dist & 63);
+                z.extra = a64<<(u8NegDist & 63);
+            } else {
+                z.v.v0 = 0;
+                z.extra = (dist == 128) ? a64 : (a64 != 0);
+            }
+        }
+    }
+    z.extra |= (extra != 0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJam256M.c b/softfloat/source/s_shiftRightJam256M.c
index 433870a..36601f8 100644
--- a/softfloat/source/s_shiftRightJam256M.c
+++ b/softfloat/source/s_shiftRightJam256M.c
@@ -1,126 +1,126 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shiftRightJam256M
-
-static
- void
-  softfloat_shortShiftRightJamM(
-      uint_fast8_t size_words,
-      const uint64_t *aPtr,
-      uint_fast8_t dist,
-      uint64_t *zPtr
-  )
-{
-    uint_fast8_t uNegDist;
-    unsigned int index, lastIndex;
-    uint64_t partWordZ, wordA;
-
-    uNegDist = -dist;
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    wordA = aPtr[index];
-    partWordZ = wordA>>dist;
-    if ( partWordZ<<dist != wordA ) partWordZ |= 1;
-    while ( index != lastIndex ) {
-        wordA = aPtr[index + wordIncr];
-        zPtr[index] = wordA<<(uNegDist & 63) | partWordZ;
-        index += wordIncr;
-        partWordZ = wordA>>dist;
-    }
-    zPtr[index] = partWordZ;
-
-}
-
-void
- softfloat_shiftRightJam256M(
-     const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr )
-{
-    uint64_t wordJam;
-    uint_fast32_t wordDist;
-    uint64_t *ptr;
-    uint_fast8_t i, innerDist;
-
-    wordJam = 0;
-    wordDist = dist>>6;
-    if ( wordDist ) {
-        if ( 4 < wordDist ) wordDist = 4;
-        ptr = (uint64_t *) (aPtr + indexMultiwordLo( 4, wordDist ));
-        i = wordDist;
-        do {
-            wordJam = *ptr++;
-            if ( wordJam ) break;
-            --i;
-        } while ( i );
-        ptr = zPtr;
-    }
-    if ( wordDist < 4 ) {
-        aPtr += indexMultiwordHiBut( 4, wordDist );
-        innerDist = dist & 63;
-        if ( innerDist ) {
-            softfloat_shortShiftRightJamM(
-                4 - wordDist,
-                aPtr,
-                innerDist,
-                zPtr + indexMultiwordLoBut( 4, wordDist )
-            );
-            if ( ! wordDist ) goto wordJam;
-        } else {
-            aPtr += indexWordLo( 4 - wordDist );
-            ptr = zPtr + indexWordLo( 4 );
-            for ( i = 4 - wordDist; i; --i ) {
-                *ptr = *aPtr;
-                aPtr += wordIncr;
-                ptr += wordIncr;
-            }
-        }
-        ptr = zPtr + indexMultiwordHi( 4, wordDist );
-    }
-    do {
-        *ptr++ = 0;
-        --wordDist;
-    } while ( wordDist );
- wordJam:
-    if ( wordJam ) zPtr[indexWordLo( 4 )] |= 1;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shiftRightJam256M
+
+static
+ void
+  softfloat_shortShiftRightJamM(
+      uint_fast8_t size_words,
+      const uint64_t *aPtr,
+      uint_fast8_t dist,
+      uint64_t *zPtr
+  )
+{
+    uint_fast8_t uNegDist;
+    unsigned int index, lastIndex;
+    uint64_t partWordZ, wordA;
+
+    uNegDist = -dist;
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    wordA = aPtr[index];
+    partWordZ = wordA>>dist;
+    if ( partWordZ<<dist != wordA ) partWordZ |= 1;
+    while ( index != lastIndex ) {
+        wordA = aPtr[index + wordIncr];
+        zPtr[index] = wordA<<(uNegDist & 63) | partWordZ;
+        index += wordIncr;
+        partWordZ = wordA>>dist;
+    }
+    zPtr[index] = partWordZ;
+
+}
+
+void
+ softfloat_shiftRightJam256M(
+     const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr )
+{
+    uint64_t wordJam;
+    uint_fast32_t wordDist;
+    uint64_t *ptr;
+    uint_fast8_t i, innerDist;
+
+    wordJam = 0;
+    wordDist = dist>>6;
+    if ( wordDist ) {
+        if ( 4 < wordDist ) wordDist = 4;
+        ptr = (uint64_t *) (aPtr + indexMultiwordLo( 4, wordDist ));
+        i = wordDist;
+        do {
+            wordJam = *ptr++;
+            if ( wordJam ) break;
+            --i;
+        } while ( i );
+        ptr = zPtr;
+    }
+    if ( wordDist < 4 ) {
+        aPtr += indexMultiwordHiBut( 4, wordDist );
+        innerDist = dist & 63;
+        if ( innerDist ) {
+            softfloat_shortShiftRightJamM(
+                4 - wordDist,
+                aPtr,
+                innerDist,
+                zPtr + indexMultiwordLoBut( 4, wordDist )
+            );
+            if ( ! wordDist ) goto wordJam;
+        } else {
+            aPtr += indexWordLo( 4 - wordDist );
+            ptr = zPtr + indexWordLo( 4 );
+            for ( i = 4 - wordDist; i; --i ) {
+                *ptr = *aPtr;
+                aPtr += wordIncr;
+                ptr += wordIncr;
+            }
+        }
+        ptr = zPtr + indexMultiwordHi( 4, wordDist );
+    }
+    do {
+        *ptr++ = 0;
+        --wordDist;
+    } while ( wordDist );
+ wordJam:
+    if ( wordJam ) zPtr[indexWordLo( 4 )] |= 1;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJam32.c b/softfloat/source/s_shiftRightJam32.c
index 2533fcd..be4622a 100644
--- a/softfloat/source/s_shiftRightJam32.c
+++ b/softfloat/source/s_shiftRightJam32.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shiftRightJam32
-
-uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )
-{
-
-    return
-        (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shiftRightJam32
+
+uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )
+{
+
+    return
+        (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJam64.c b/softfloat/source/s_shiftRightJam64.c
index 4b40e3d..733c173 100644
--- a/softfloat/source/s_shiftRightJam64.c
+++ b/softfloat/source/s_shiftRightJam64.c
@@ -1,51 +1,51 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shiftRightJam64
-
-uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )
-{
-
-    return
-        (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shiftRightJam64
+
+uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )
+{
+
+    return
+        (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJam64Extra.c b/softfloat/source/s_shiftRightJam64Extra.c
index b93fad3..2c5609b 100644
--- a/softfloat/source/s_shiftRightJam64Extra.c
+++ b/softfloat/source/s_shiftRightJam64Extra.c
@@ -1,62 +1,62 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shiftRightJam64Extra
-
-struct uint64_extra
- softfloat_shiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast32_t dist )
-{
-    struct uint64_extra z;
-
-    if ( dist < 64 ) {
-        z.v = a>>dist;
-        z.extra = a<<(-dist & 63);
-    } else {
-        z.v = 0;
-        z.extra = (dist == 64) ? a : (a != 0);
-    }
-    z.extra |= (extra != 0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shiftRightJam64Extra
+
+struct uint64_extra
+ softfloat_shiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast32_t dist )
+{
+    struct uint64_extra z;
+
+    if ( dist < 64 ) {
+        z.v = a>>dist;
+        z.extra = a<<(-dist & 63);
+    } else {
+        z.v = 0;
+        z.extra = (dist == 64) ? a : (a != 0);
+    }
+    z.extra |= (extra != 0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightJamM.c b/softfloat/source/s_shiftRightJamM.c
index edf5f95..0a0dd7d 100644
--- a/softfloat/source/s_shiftRightJamM.c
+++ b/softfloat/source/s_shiftRightJamM.c
@@ -1,101 +1,101 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shiftRightJamM
-
-#define softfloat_shiftRightJamM softfloat_shiftRightJamM
-#include "primitives.h"
-
-void
- softfloat_shiftRightJamM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- )
-{
-    uint32_t wordJam, wordDist, *ptr;
-    uint_fast8_t i, innerDist;
-
-    wordJam = 0;
-    wordDist = dist>>5;
-    if ( wordDist ) {
-        if ( size_words < wordDist ) wordDist = size_words;
-        ptr = (uint32_t *) (aPtr + indexMultiwordLo( size_words, wordDist ));
-        i = wordDist;
-        do {
-            wordJam = *ptr++;
-            if ( wordJam ) break;
-            --i;
-        } while ( i );
-        ptr = zPtr;
-    }
-    if ( wordDist < size_words ) {
-        aPtr += indexMultiwordHiBut( size_words, wordDist );
-        innerDist = dist & 31;
-        if ( innerDist ) {
-            softfloat_shortShiftRightJamM(
-                size_words - wordDist,
-                aPtr,
-                innerDist,
-                zPtr + indexMultiwordLoBut( size_words, wordDist )
-            );
-            if ( ! wordDist ) goto wordJam;
-        } else {
-            aPtr += indexWordLo( size_words - wordDist );
-            ptr = zPtr + indexWordLo( size_words );
-            for ( i = size_words - wordDist; i; --i ) {
-                *ptr = *aPtr;
-                aPtr += wordIncr;
-                ptr += wordIncr;
-            }
-        }
-        ptr = zPtr + indexMultiwordHi( size_words, wordDist );
-    }
-    do {
-        *ptr++ = 0;
-        --wordDist;
-    } while ( wordDist );
- wordJam:
-    if ( wordJam ) zPtr[indexWordLo( size_words )] |= 1;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shiftRightJamM
+
+#define softfloat_shiftRightJamM softfloat_shiftRightJamM
+#include "primitives.h"
+
+void
+ softfloat_shiftRightJamM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint32_t wordJam, wordDist, *ptr;
+    uint_fast8_t i, innerDist;
+
+    wordJam = 0;
+    wordDist = dist>>5;
+    if ( wordDist ) {
+        if ( size_words < wordDist ) wordDist = size_words;
+        ptr = (uint32_t *) (aPtr + indexMultiwordLo( size_words, wordDist ));
+        i = wordDist;
+        do {
+            wordJam = *ptr++;
+            if ( wordJam ) break;
+            --i;
+        } while ( i );
+        ptr = zPtr;
+    }
+    if ( wordDist < size_words ) {
+        aPtr += indexMultiwordHiBut( size_words, wordDist );
+        innerDist = dist & 31;
+        if ( innerDist ) {
+            softfloat_shortShiftRightJamM(
+                size_words - wordDist,
+                aPtr,
+                innerDist,
+                zPtr + indexMultiwordLoBut( size_words, wordDist )
+            );
+            if ( ! wordDist ) goto wordJam;
+        } else {
+            aPtr += indexWordLo( size_words - wordDist );
+            ptr = zPtr + indexWordLo( size_words );
+            for ( i = size_words - wordDist; i; --i ) {
+                *ptr = *aPtr;
+                aPtr += wordIncr;
+                ptr += wordIncr;
+            }
+        }
+        ptr = zPtr + indexMultiwordHi( size_words, wordDist );
+    }
+    do {
+        *ptr++ = 0;
+        --wordDist;
+    } while ( wordDist );
+ wordJam:
+    if ( wordJam ) zPtr[indexWordLo( size_words )] |= 1;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shiftRightM.c b/softfloat/source/s_shiftRightM.c
index 00265ea..6ac383f 100644
--- a/softfloat/source/s_shiftRightM.c
+++ b/softfloat/source/s_shiftRightM.c
@@ -1,91 +1,91 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shiftRightM
-
-#define softfloat_shiftRightM softfloat_shiftRightM
-#include "primitives.h"
-
-void
- softfloat_shiftRightM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- )
-{
-    uint32_t wordDist;
-    uint_fast8_t innerDist;
-    uint32_t *destPtr;
-    uint_fast8_t i;
-
-    wordDist = dist>>5;
-    if ( wordDist < size_words ) {
-        aPtr += indexMultiwordHiBut( size_words, wordDist );
-        innerDist = dist & 31;
-        if ( innerDist ) {
-            softfloat_shortShiftRightM(
-                size_words - wordDist,
-                aPtr,
-                innerDist,
-                zPtr + indexMultiwordLoBut( size_words, wordDist )
-            );
-            if ( ! wordDist ) return;
-        } else {
-            aPtr += indexWordLo( size_words - wordDist );
-            destPtr = zPtr + indexWordLo( size_words );
-            for ( i = size_words - wordDist; i; --i ) {
-                *destPtr = *aPtr;
-                aPtr += wordIncr;
-                destPtr += wordIncr;
-            }
-        }
-        zPtr += indexMultiwordHi( size_words, wordDist );
-    } else {
-        wordDist = size_words;
-    }
-    do {
-        *zPtr++ = 0;
-        --wordDist;
-    } while ( wordDist );
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shiftRightM
+
+#define softfloat_shiftRightM softfloat_shiftRightM
+#include "primitives.h"
+
+void
+ softfloat_shiftRightM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint32_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint32_t wordDist;
+    uint_fast8_t innerDist;
+    uint32_t *destPtr;
+    uint_fast8_t i;
+
+    wordDist = dist>>5;
+    if ( wordDist < size_words ) {
+        aPtr += indexMultiwordHiBut( size_words, wordDist );
+        innerDist = dist & 31;
+        if ( innerDist ) {
+            softfloat_shortShiftRightM(
+                size_words - wordDist,
+                aPtr,
+                innerDist,
+                zPtr + indexMultiwordLoBut( size_words, wordDist )
+            );
+            if ( ! wordDist ) return;
+        } else {
+            aPtr += indexWordLo( size_words - wordDist );
+            destPtr = zPtr + indexWordLo( size_words );
+            for ( i = size_words - wordDist; i; --i ) {
+                *destPtr = *aPtr;
+                aPtr += wordIncr;
+                destPtr += wordIncr;
+            }
+        }
+        zPtr += indexMultiwordHi( size_words, wordDist );
+    } else {
+        wordDist = size_words;
+    }
+    do {
+        *zPtr++ = 0;
+        --wordDist;
+    } while ( wordDist );
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftLeft128.c b/softfloat/source/s_shortShiftLeft128.c
index 7513bc6..9e0b8be 100644
--- a/softfloat/source/s_shortShiftLeft128.c
+++ b/softfloat/source/s_shortShiftLeft128.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftLeft128
-
-struct uint128
- softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
-    struct uint128 z;
-
-    z.v64 = a64<<dist | a0>>(-dist & 63);
-    z.v0 = a0<<dist;
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftLeft128
+
+struct uint128
+ softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    struct uint128 z;
+
+    z.v64 = a64<<dist | a0>>(-dist & 63);
+    z.v0 = a0<<dist;
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftLeft64To96M.c b/softfloat/source/s_shortShiftLeft64To96M.c
index ce1f09b..2f442ec 100644
--- a/softfloat/source/s_shortShiftLeft64To96M.c
+++ b/softfloat/source/s_shortShiftLeft64To96M.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftLeft64To96M
-
-void
- softfloat_shortShiftLeft64To96M(
-     uint64_t a, uint_fast8_t dist, uint32_t *zPtr )
-{
-
-    zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
-    a >>= 32 - dist;
-    zPtr[indexWord( 3, 2 )] = a>>32;
-    zPtr[indexWord( 3, 1 )] = a;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftLeft64To96M
+
+void
+ softfloat_shortShiftLeft64To96M(
+     uint64_t a, uint_fast8_t dist, uint32_t *zPtr )
+{
+
+    zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
+    a >>= 32 - dist;
+    zPtr[indexWord( 3, 2 )] = a>>32;
+    zPtr[indexWord( 3, 1 )] = a;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftLeftM.c b/softfloat/source/s_shortShiftLeftM.c
index 48e6e03..b947c63 100644
--- a/softfloat/source/s_shortShiftLeftM.c
+++ b/softfloat/source/s_shortShiftLeftM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftLeftM
-
-void
- softfloat_shortShiftLeftM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- )
-{
-    uint_fast8_t uNegDist;
-    unsigned int index, lastIndex;
-    uint32_t partWordZ, wordA;
-
-    uNegDist = -dist;
-    index = indexWordHi( size_words );
-    lastIndex = indexWordLo( size_words );
-    partWordZ = aPtr[index]<<dist;
-    while ( index != lastIndex ) {
-        wordA = aPtr[index - wordIncr];
-        zPtr[index] = partWordZ | wordA>>(uNegDist & 31);
-        index -= wordIncr;
-        partWordZ = wordA<<dist;
-    }
-    zPtr[index] = partWordZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftLeftM
+
+void
+ softfloat_shortShiftLeftM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint_fast8_t uNegDist;
+    unsigned int index, lastIndex;
+    uint32_t partWordZ, wordA;
+
+    uNegDist = -dist;
+    index = indexWordHi( size_words );
+    lastIndex = indexWordLo( size_words );
+    partWordZ = aPtr[index]<<dist;
+    while ( index != lastIndex ) {
+        wordA = aPtr[index - wordIncr];
+        zPtr[index] = partWordZ | wordA>>(uNegDist & 31);
+        index -= wordIncr;
+        partWordZ = wordA<<dist;
+    }
+    zPtr[index] = partWordZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRight128.c b/softfloat/source/s_shortShiftRight128.c
index 8f5c650..16a5cc0 100644
--- a/softfloat/source/s_shortShiftRight128.c
+++ b/softfloat/source/s_shortShiftRight128.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRight128
-
-struct uint128
- softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
-    struct uint128 z;
-
-    z.v64 = a64>>dist;
-    z.v0 = a64<<(-dist & 63) | a0>>dist;
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRight128
+
+struct uint128
+ softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    struct uint128 z;
+
+    z.v64 = a64>>dist;
+    z.v0 = a64<<(-dist & 63) | a0>>dist;
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightExtendM.c b/softfloat/source/s_shortShiftRightExtendM.c
index bc441c7..92c786a 100644
--- a/softfloat/source/s_shortShiftRightExtendM.c
+++ b/softfloat/source/s_shortShiftRightExtendM.c
@@ -1,73 +1,73 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightExtendM
-
-void
- softfloat_shortShiftRightExtendM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- )
-{
-    uint_fast8_t uNegDist;
-    unsigned int indexA, lastIndexA;
-    uint32_t partWordZ, wordA;
-
-    uNegDist = -dist;
-    indexA = indexWordLo( size_words );
-    lastIndexA = indexWordHi( size_words );
-    zPtr += indexWordLo( size_words + 1 );
-    partWordZ = 0;
-    for (;;) {
-        wordA = aPtr[indexA];
-        *zPtr = wordA<<(uNegDist & 31) | partWordZ;
-        zPtr += wordIncr;
-        partWordZ = wordA>>dist;
-        if ( indexA == lastIndexA ) break;
-        indexA += wordIncr;
-    }
-    *zPtr = partWordZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightExtendM
+
+void
+ softfloat_shortShiftRightExtendM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint_fast8_t uNegDist;
+    unsigned int indexA, lastIndexA;
+    uint32_t partWordZ, wordA;
+
+    uNegDist = -dist;
+    indexA = indexWordLo( size_words );
+    lastIndexA = indexWordHi( size_words );
+    zPtr += indexWordLo( size_words + 1 );
+    partWordZ = 0;
+    for (;;) {
+        wordA = aPtr[indexA];
+        *zPtr = wordA<<(uNegDist & 31) | partWordZ;
+        zPtr += wordIncr;
+        partWordZ = wordA>>dist;
+        if ( indexA == lastIndexA ) break;
+        indexA += wordIncr;
+    }
+    *zPtr = partWordZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightJam128.c b/softfloat/source/s_shortShiftRightJam128.c
index 7600872..8a75a71 100644
--- a/softfloat/source/s_shortShiftRightJam128.c
+++ b/softfloat/source/s_shortShiftRightJam128.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightJam128
-
-struct uint128
- softfloat_shortShiftRightJam128(
-     uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
-    uint_fast8_t uNegDist;
-    struct uint128 z;
-
-    uNegDist = -dist;
-    z.v64 = a64>>dist;
-    z.v0 =
-        a64<<(uNegDist & 63) | a0>>dist
-            | ((uint64_t) (a0<<(uNegDist & 63)) != 0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightJam128
+
+struct uint128
+ softfloat_shortShiftRightJam128(
+     uint64_t a64, uint64_t a0, uint_fast8_t dist )
+{
+    uint_fast8_t uNegDist;
+    struct uint128 z;
+
+    uNegDist = -dist;
+    z.v64 = a64>>dist;
+    z.v0 =
+        a64<<(uNegDist & 63) | a0>>dist
+            | ((uint64_t) (a0<<(uNegDist & 63)) != 0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightJam128Extra.c b/softfloat/source/s_shortShiftRightJam128Extra.c
index b077440..b5d4e1c 100644
--- a/softfloat/source/s_shortShiftRightJam128Extra.c
+++ b/softfloat/source/s_shortShiftRightJam128Extra.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightJam128Extra
-
-struct uint128_extra
- softfloat_shortShiftRightJam128Extra(
-     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )
-{
-    uint_fast8_t uNegDist;
-    struct uint128_extra z;
-
-    uNegDist = -dist;
-    z.v.v64 = a64>>dist;
-    z.v.v0 = a64<<(uNegDist & 63) | a0>>dist;
-    z.extra = a0<<(uNegDist & 63) | (extra != 0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightJam128Extra
+
+struct uint128_extra
+ softfloat_shortShiftRightJam128Extra(
+     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )
+{
+    uint_fast8_t uNegDist;
+    struct uint128_extra z;
+
+    uNegDist = -dist;
+    z.v.v64 = a64>>dist;
+    z.v.v0 = a64<<(uNegDist & 63) | a0>>dist;
+    z.extra = a0<<(uNegDist & 63) | (extra != 0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightJam64.c b/softfloat/source/s_shortShiftRightJam64.c
index d3044c8..1a7724f 100644
--- a/softfloat/source/s_shortShiftRightJam64.c
+++ b/softfloat/source/s_shortShiftRightJam64.c
@@ -1,50 +1,50 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-
-#ifndef softfloat_shortShiftRightJam64
-
-uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )
-{
-
-    return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0);
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+
+#ifndef softfloat_shortShiftRightJam64
+
+uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )
+{
+
+    return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0);
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightJam64Extra.c b/softfloat/source/s_shortShiftRightJam64Extra.c
index f2af92b..680369c 100644
--- a/softfloat/source/s_shortShiftRightJam64Extra.c
+++ b/softfloat/source/s_shortShiftRightJam64Extra.c
@@ -1,56 +1,56 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightJam64Extra
-
-struct uint64_extra
- softfloat_shortShiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast8_t dist )
-{
-    struct uint64_extra z;
-
-    z.v = a>>dist;
-    z.extra = a<<(-dist & 63) | (extra != 0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightJam64Extra
+
+struct uint64_extra
+ softfloat_shortShiftRightJam64Extra(
+     uint64_t a, uint64_t extra, uint_fast8_t dist )
+{
+    struct uint64_extra z;
+
+    z.v = a>>dist;
+    z.extra = a<<(-dist & 63) | (extra != 0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightJamM.c b/softfloat/source/s_shortShiftRightJamM.c
index b567e48..60f698b 100644
--- a/softfloat/source/s_shortShiftRightJamM.c
+++ b/softfloat/source/s_shortShiftRightJamM.c
@@ -1,72 +1,72 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightJamM
-
-void
- softfloat_shortShiftRightJamM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- )
-{
-    uint_fast8_t uNegDist;
-    unsigned int index, lastIndex;
-    uint32_t partWordZ, wordA;
-
-    uNegDist = -dist;
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    wordA = aPtr[index];
-    partWordZ = wordA>>dist;
-    if ( partWordZ<<dist != wordA ) partWordZ |= 1;
-    while ( index != lastIndex ) {
-        wordA = aPtr[index + wordIncr];
-        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
-        index += wordIncr;
-        partWordZ = wordA>>dist;
-    }
-    zPtr[index] = partWordZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightJamM
+
+void
+ softfloat_shortShiftRightJamM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint_fast8_t uNegDist;
+    unsigned int index, lastIndex;
+    uint32_t partWordZ, wordA;
+
+    uNegDist = -dist;
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    wordA = aPtr[index];
+    partWordZ = wordA>>dist;
+    if ( partWordZ<<dist != wordA ) partWordZ |= 1;
+    while ( index != lastIndex ) {
+        wordA = aPtr[index + wordIncr];
+        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
+        index += wordIncr;
+        partWordZ = wordA>>dist;
+    }
+    zPtr[index] = partWordZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_shortShiftRightM.c b/softfloat/source/s_shortShiftRightM.c
index 54e0071..8a165fe 100644
--- a/softfloat/source/s_shortShiftRightM.c
+++ b/softfloat/source/s_shortShiftRightM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_shortShiftRightM
-
-void
- softfloat_shortShiftRightM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- )
-{
-    uint_fast8_t uNegDist;
-    unsigned int index, lastIndex;
-    uint32_t partWordZ, wordA;
-
-    uNegDist = -dist;
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    partWordZ = aPtr[index]>>dist;
-    while ( index != lastIndex ) {
-        wordA = aPtr[index + wordIncr];
-        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
-        index += wordIncr;
-        partWordZ = wordA>>dist;
-    }
-    zPtr[index] = partWordZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_shortShiftRightM
+
+void
+ softfloat_shortShiftRightM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     uint_fast8_t dist,
+     uint32_t *zPtr
+ )
+{
+    uint_fast8_t uNegDist;
+    unsigned int index, lastIndex;
+    uint32_t partWordZ, wordA;
+
+    uNegDist = -dist;
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    partWordZ = aPtr[index]>>dist;
+    while ( index != lastIndex ) {
+        wordA = aPtr[index + wordIncr];
+        zPtr[index] = wordA<<(uNegDist & 31) | partWordZ;
+        index += wordIncr;
+        partWordZ = wordA>>dist;
+    }
+    zPtr[index] = partWordZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_sub128.c b/softfloat/source/s_sub128.c
index 9bf3463..4691aec 100644
--- a/softfloat/source/s_sub128.c
+++ b/softfloat/source/s_sub128.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_sub128
-
-struct uint128
- softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
-    struct uint128 z;
-
-    z.v0 = a0 - b0;
-    z.v64 = a64 - b64 - (a0 < b0);
-    return z;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_sub128
+
+struct uint128
+ softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
+{
+    struct uint128 z;
+
+    z.v0 = a0 - b0;
+    z.v64 = a64 - b64 - (a0 < b0);
+    return z;
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_sub1XM.c b/softfloat/source/s_sub1XM.c
index 30c5d36..6c79a8b 100644
--- a/softfloat/source/s_sub1XM.c
+++ b/softfloat/source/s_sub1XM.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_sub1XM
-
-void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr )
-{
-    unsigned int index, lastIndex;
-    uint32_t wordA;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    for (;;) {
-        wordA = zPtr[index];
-        zPtr[index] = wordA - 1;
-        if ( wordA || (index == lastIndex) ) break;
-        index += wordIncr;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_sub1XM
+
+void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr )
+{
+    unsigned int index, lastIndex;
+    uint32_t wordA;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    for (;;) {
+        wordA = zPtr[index];
+        zPtr[index] = wordA - 1;
+        if ( wordA || (index == lastIndex) ) break;
+        index += wordIncr;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_sub256M.c b/softfloat/source/s_sub256M.c
index a4af5a1..a1f9f89 100644
--- a/softfloat/source/s_sub256M.c
+++ b/softfloat/source/s_sub256M.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_sub256M
-
-void
- softfloat_sub256M(
-     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )
-{
-    unsigned int index;
-    uint_fast8_t borrow;
-    uint64_t wordA, wordB;
-
-    index = indexWordLo( 4 );
-    borrow = 0;
-    for (;;) {
-        wordA = aPtr[index];
-        wordB = bPtr[index];
-        zPtr[index] = wordA - wordB - borrow;
-        if ( index == indexWordHi( 4 ) ) break;
-        borrow = borrow ? (wordA <= wordB) : (wordA < wordB);
-        index += wordIncr;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_sub256M
+
+void
+ softfloat_sub256M(
+     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr )
+{
+    unsigned int index;
+    uint_fast8_t borrow;
+    uint64_t wordA, wordB;
+
+    index = indexWordLo( 4 );
+    borrow = 0;
+    for (;;) {
+        wordA = aPtr[index];
+        wordB = bPtr[index];
+        zPtr[index] = wordA - wordB - borrow;
+        if ( index == indexWordHi( 4 ) ) break;
+        borrow = borrow ? (wordA <= wordB) : (wordA < wordB);
+        index += wordIncr;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_subM.c b/softfloat/source/s_subM.c
index fcccc74..213b0bf 100644
--- a/softfloat/source/s_subM.c
+++ b/softfloat/source/s_subM.c
@@ -1,70 +1,70 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "primitiveTypes.h"
-
-#ifndef softfloat_subM
-
-void
- softfloat_subM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint32_t *zPtr
- )
-{
-    unsigned int index, lastIndex;
-    uint_fast8_t borrow;
-    uint32_t wordA, wordB;
-
-    index = indexWordLo( size_words );
-    lastIndex = indexWordHi( size_words );
-    borrow = 0;
-    for (;;) {
-        wordA = aPtr[index];
-        wordB = bPtr[index];
-        zPtr[index] = wordA - wordB - borrow;
-        if ( index == lastIndex ) break;
-        borrow = borrow ? (wordA <= wordB) : (wordA < wordB);
-        index += wordIncr;
-    }
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "primitiveTypes.h"
+
+#ifndef softfloat_subM
+
+void
+ softfloat_subM(
+     uint_fast8_t size_words,
+     const uint32_t *aPtr,
+     const uint32_t *bPtr,
+     uint32_t *zPtr
+ )
+{
+    unsigned int index, lastIndex;
+    uint_fast8_t borrow;
+    uint32_t wordA, wordB;
+
+    index = indexWordLo( size_words );
+    lastIndex = indexWordHi( size_words );
+    borrow = 0;
+    for (;;) {
+        wordA = aPtr[index];
+        wordB = bPtr[index];
+        zPtr[index] = wordA - wordB - borrow;
+        if ( index == lastIndex ) break;
+        borrow = borrow ? (wordA <= wordB) : (wordA < wordB);
+        index += wordIncr;
+    }
+
+}
+
+#endif
+
diff --git a/softfloat/source/s_subMagsExtF80.c b/softfloat/source/s_subMagsExtF80.c
index 0c46c61..86ffd9b 100644
--- a/softfloat/source/s_subMagsExtF80.c
+++ b/softfloat/source/s_subMagsExtF80.c
@@ -1,158 +1,158 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-extFloat80_t
- softfloat_subMagsExtF80(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0,
-     bool signZ
- )
-{
-    int_fast32_t expA;
-    uint_fast64_t sigA;
-    int_fast32_t expB;
-    uint_fast64_t sigB;
-    int_fast32_t expDiff;
-    uint_fast16_t uiZ64;
-    uint_fast64_t uiZ0;
-    int_fast32_t expZ;
-    uint_fast64_t sigExtra;
-    struct uint128 sig128, uiZ;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expExtF80UI64( uiA64 );
-    sigA = uiA0;
-    expB = expExtF80UI64( uiB64 );
-    sigB = uiB0;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( 0 < expDiff ) goto expABigger;
-    if ( expDiff < 0 ) goto expBBigger;
-    if ( expA == 0x7FFF ) {
-        if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
-            goto propagateNaN;
-        }
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ64 = defaultNaNExtF80UI64;
-        uiZ0  = defaultNaNExtF80UI0;
-        goto uiZ;
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expZ = expA;
-    if ( ! expZ ) expZ = 1;
-    sigExtra = 0;
-    if ( sigB < sigA ) goto aBigger;
-    if ( sigA < sigB ) goto bBigger;
-    uiZ64 =
-        packToExtF80UI64( (softfloat_roundingMode == softfloat_round_min), 0 );
-    uiZ0 = 0;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- expBBigger:
-    if ( expB == 0x7FFF ) {
-        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        uiZ64 = packToExtF80UI64( signZ ^ 1, 0x7FFF );
-        uiZ0  = UINT64_C( 0x8000000000000000 );
-        goto uiZ;
-    }
-    if ( ! expA ) {
-        ++expDiff;
-        sigExtra = 0;
-        if ( ! expDiff ) goto newlyAlignedBBigger;
-    }
-    sig128 = softfloat_shiftRightJam128( sigA, 0, -expDiff );
-    sigA = sig128.v64;
-    sigExtra = sig128.v0;
- newlyAlignedBBigger:
-    expZ = expB;
- bBigger:
-    signZ = ! signZ;
-    sig128 = softfloat_sub128( sigB, 0, sigA, sigExtra );
-    goto normRoundPack;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- expABigger:
-    if ( expA == 0x7FFF ) {
-        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
-        uiZ64 = uiA64;
-        uiZ0  = uiA0;
-        goto uiZ;
-    }
-    if ( ! expB ) {
-        --expDiff;
-        sigExtra = 0;
-        if ( ! expDiff ) goto newlyAlignedABigger;
-    }
-    sig128 = softfloat_shiftRightJam128( sigB, 0, expDiff );
-    sigB = sig128.v64;
-    sigExtra = sig128.v0;
- newlyAlignedABigger:
-    expZ = expA;
- aBigger:
-    sig128 = softfloat_sub128( sigA, 0, sigB, sigExtra );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- normRoundPack:
-    return
-        softfloat_normRoundPackToExtF80(
-            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
-    uiZ64 = uiZ.v64;
-    uiZ0  = uiZ.v0;
- uiZ:
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+extFloat80_t
+ softfloat_subMagsExtF80(
+     uint_fast16_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast16_t uiB64,
+     uint_fast64_t uiB0,
+     bool signZ
+ )
+{
+    int_fast32_t expA;
+    uint_fast64_t sigA;
+    int_fast32_t expB;
+    uint_fast64_t sigB;
+    int_fast32_t expDiff;
+    uint_fast16_t uiZ64;
+    uint_fast64_t uiZ0;
+    int_fast32_t expZ;
+    uint_fast64_t sigExtra;
+    struct uint128 sig128, uiZ;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expExtF80UI64( uiA64 );
+    sigA = uiA0;
+    expB = expExtF80UI64( uiB64 );
+    sigB = uiB0;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( 0 < expDiff ) goto expABigger;
+    if ( expDiff < 0 ) goto expBBigger;
+    if ( expA == 0x7FFF ) {
+        if ( (sigA | sigB) & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) {
+            goto propagateNaN;
+        }
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ64 = defaultNaNExtF80UI64;
+        uiZ0  = defaultNaNExtF80UI0;
+        goto uiZ;
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expZ = expA;
+    if ( ! expZ ) expZ = 1;
+    sigExtra = 0;
+    if ( sigB < sigA ) goto aBigger;
+    if ( sigA < sigB ) goto bBigger;
+    uiZ64 =
+        packToExtF80UI64( (softfloat_roundingMode == softfloat_round_min), 0 );
+    uiZ0 = 0;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ expBBigger:
+    if ( expB == 0x7FFF ) {
+        if ( sigB & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        uiZ64 = packToExtF80UI64( signZ ^ 1, 0x7FFF );
+        uiZ0  = UINT64_C( 0x8000000000000000 );
+        goto uiZ;
+    }
+    if ( ! expA ) {
+        ++expDiff;
+        sigExtra = 0;
+        if ( ! expDiff ) goto newlyAlignedBBigger;
+    }
+    sig128 = softfloat_shiftRightJam128( sigA, 0, -expDiff );
+    sigA = sig128.v64;
+    sigExtra = sig128.v0;
+ newlyAlignedBBigger:
+    expZ = expB;
+ bBigger:
+    signZ = ! signZ;
+    sig128 = softfloat_sub128( sigB, 0, sigA, sigExtra );
+    goto normRoundPack;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ expABigger:
+    if ( expA == 0x7FFF ) {
+        if ( sigA & UINT64_C( 0x7FFFFFFFFFFFFFFF ) ) goto propagateNaN;
+        uiZ64 = uiA64;
+        uiZ0  = uiA0;
+        goto uiZ;
+    }
+    if ( ! expB ) {
+        --expDiff;
+        sigExtra = 0;
+        if ( ! expDiff ) goto newlyAlignedABigger;
+    }
+    sig128 = softfloat_shiftRightJam128( sigB, 0, expDiff );
+    sigB = sig128.v64;
+    sigExtra = sig128.v0;
+ newlyAlignedABigger:
+    expZ = expA;
+ aBigger:
+    sig128 = softfloat_sub128( sigA, 0, sigB, sigExtra );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ normRoundPack:
+    return
+        softfloat_normRoundPackToExtF80(
+            signZ, expZ, sig128.v64, sig128.v0, extF80_roundingPrecision );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNExtF80UI( uiA64, uiA0, uiB64, uiB0 );
+    uiZ64 = uiZ.v64;
+    uiZ0  = uiZ.v0;
+ uiZ:
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_subMagsF128.c b/softfloat/source/s_subMagsF128.c
index e93543f..595ed7e 100644
--- a/softfloat/source/s_subMagsF128.c
+++ b/softfloat/source/s_subMagsF128.c
@@ -1,139 +1,139 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float128_t
- softfloat_subMagsF128(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0,
-     bool signZ
- )
-{
-    int_fast32_t expA;
-    struct uint128 sigA;
-    int_fast32_t expB;
-    struct uint128 sigB, sigZ;
-    int_fast32_t expDiff, expZ;
-    struct uint128 uiZ;
-    union ui128_f128 uZ;
-
-    expA = expF128UI64( uiA64 );
-    sigA.v64 = fracF128UI64( uiA64 );
-    sigA.v0  = uiA0;
-    expB = expF128UI64( uiB64 );
-    sigB.v64 = fracF128UI64( uiB64 );
-    sigB.v0  = uiB0;
-    sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 4 );
-    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 4 );
-    expDiff = expA - expB;
-    if ( 0 < expDiff ) goto expABigger;
-    if ( expDiff < 0 ) goto expBBigger;
-    if ( expA == 0x7FFF ) {
-        if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
-        softfloat_raiseFlags( softfloat_flag_invalid );
-        uiZ.v64 = defaultNaNF128UI64;
-        uiZ.v0  = defaultNaNF128UI0;
-        goto uiZ;
-    }
-    expZ = expA;
-    if ( ! expZ ) expZ = 1;
-    if ( sigB.v64 < sigA.v64 ) goto aBigger;
-    if ( sigA.v64 < sigB.v64 ) goto bBigger;
-    if ( sigB.v0 < sigA.v0 ) goto aBigger;
-    if ( sigA.v0 < sigB.v0 ) goto bBigger;
-    uiZ.v64 =
-        packToF128UI64(
-            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    uiZ.v0 = 0;
-    goto uiZ;
- expBBigger:
-    if ( expB == 0x7FFF ) {
-        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
-        uiZ.v64 = packToF128UI64( signZ ^ 1, 0x7FFF, 0 );
-        uiZ.v0  = 0;
-        goto uiZ;
-    }
-    if ( expA ) {
-        sigA.v64 |= UINT64_C( 0x0010000000000000 );
-    } else {
-        ++expDiff;
-        if ( ! expDiff ) goto newlyAlignedBBigger;
-    }
-    sigA = softfloat_shiftRightJam128( sigA.v64, sigA.v0, -expDiff );
- newlyAlignedBBigger:
-    expZ = expB;
-    sigB.v64 |= UINT64_C( 0x0010000000000000 );
- bBigger:
-    signZ = ! signZ;
-    sigZ = softfloat_sub128( sigB.v64, sigB.v0, sigA.v64, sigA.v0 );
-    goto normRoundPack;
- expABigger:
-    if ( expA == 0x7FFF ) {
-        if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
-        uiZ.v64 = uiA64;
-        uiZ.v0  = uiA0;
-        goto uiZ;
-    }
-    if ( expB ) {
-        sigB.v64 |= UINT64_C( 0x0010000000000000 );
-    } else {
-        --expDiff;
-        if ( ! expDiff ) goto newlyAlignedABigger;
-    }
-    sigB = softfloat_shiftRightJam128( sigB.v64, sigB.v0, expDiff );
- newlyAlignedABigger:
-    expZ = expA;
-    sigA.v64 |= UINT64_C( 0x0010000000000000 );
- aBigger:
-    sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
- normRoundPack:
-    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );
- propagateNaN:
-    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float128_t
+ softfloat_subMagsF128(
+     uint_fast64_t uiA64,
+     uint_fast64_t uiA0,
+     uint_fast64_t uiB64,
+     uint_fast64_t uiB0,
+     bool signZ
+ )
+{
+    int_fast32_t expA;
+    struct uint128 sigA;
+    int_fast32_t expB;
+    struct uint128 sigB, sigZ;
+    int_fast32_t expDiff, expZ;
+    struct uint128 uiZ;
+    union ui128_f128 uZ;
+
+    expA = expF128UI64( uiA64 );
+    sigA.v64 = fracF128UI64( uiA64 );
+    sigA.v0  = uiA0;
+    expB = expF128UI64( uiB64 );
+    sigB.v64 = fracF128UI64( uiB64 );
+    sigB.v0  = uiB0;
+    sigA = softfloat_shortShiftLeft128( sigA.v64, sigA.v0, 4 );
+    sigB = softfloat_shortShiftLeft128( sigB.v64, sigB.v0, 4 );
+    expDiff = expA - expB;
+    if ( 0 < expDiff ) goto expABigger;
+    if ( expDiff < 0 ) goto expBBigger;
+    if ( expA == 0x7FFF ) {
+        if ( sigA.v64 | sigA.v0 | sigB.v64 | sigB.v0 ) goto propagateNaN;
+        softfloat_raiseFlags( softfloat_flag_invalid );
+        uiZ.v64 = defaultNaNF128UI64;
+        uiZ.v0  = defaultNaNF128UI0;
+        goto uiZ;
+    }
+    expZ = expA;
+    if ( ! expZ ) expZ = 1;
+    if ( sigB.v64 < sigA.v64 ) goto aBigger;
+    if ( sigA.v64 < sigB.v64 ) goto bBigger;
+    if ( sigB.v0 < sigA.v0 ) goto aBigger;
+    if ( sigA.v0 < sigB.v0 ) goto bBigger;
+    uiZ.v64 =
+        packToF128UI64(
+            (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    uiZ.v0 = 0;
+    goto uiZ;
+ expBBigger:
+    if ( expB == 0x7FFF ) {
+        if ( sigB.v64 | sigB.v0 ) goto propagateNaN;
+        uiZ.v64 = packToF128UI64( signZ ^ 1, 0x7FFF, 0 );
+        uiZ.v0  = 0;
+        goto uiZ;
+    }
+    if ( expA ) {
+        sigA.v64 |= UINT64_C( 0x0010000000000000 );
+    } else {
+        ++expDiff;
+        if ( ! expDiff ) goto newlyAlignedBBigger;
+    }
+    sigA = softfloat_shiftRightJam128( sigA.v64, sigA.v0, -expDiff );
+ newlyAlignedBBigger:
+    expZ = expB;
+    sigB.v64 |= UINT64_C( 0x0010000000000000 );
+ bBigger:
+    signZ = ! signZ;
+    sigZ = softfloat_sub128( sigB.v64, sigB.v0, sigA.v64, sigA.v0 );
+    goto normRoundPack;
+ expABigger:
+    if ( expA == 0x7FFF ) {
+        if ( sigA.v64 | sigA.v0 ) goto propagateNaN;
+        uiZ.v64 = uiA64;
+        uiZ.v0  = uiA0;
+        goto uiZ;
+    }
+    if ( expB ) {
+        sigB.v64 |= UINT64_C( 0x0010000000000000 );
+    } else {
+        --expDiff;
+        if ( ! expDiff ) goto newlyAlignedABigger;
+    }
+    sigB = softfloat_shiftRightJam128( sigB.v64, sigB.v0, expDiff );
+ newlyAlignedABigger:
+    expZ = expA;
+    sigA.v64 |= UINT64_C( 0x0010000000000000 );
+ aBigger:
+    sigZ = softfloat_sub128( sigA.v64, sigA.v0, sigB.v64, sigB.v0 );
+ normRoundPack:
+    return softfloat_normRoundPackToF128( signZ, expZ - 5, sigZ.v64, sigZ.v0 );
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF128UI( uiA64, uiA0, uiB64, uiB0 );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_subMagsF16.c b/softfloat/source/s_subMagsF16.c
index ae1417e..6bbcb5c 100644
--- a/softfloat/source/s_subMagsF16.c
+++ b/softfloat/source/s_subMagsF16.c
@@ -1,187 +1,187 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
-University of California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
-{
-    int_fast8_t expA;
-    uint_fast16_t sigA;
-    int_fast8_t expB;
-    uint_fast16_t sigB;
-    int_fast8_t expDiff;
-    uint_fast16_t uiZ;
-    int_fast16_t sigDiff;
-    bool signZ;
-    int_fast8_t shiftDist, expZ;
-    uint_fast16_t sigZ, sigX, sigY;
-    uint_fast32_t sig32Z;
-    int_fast8_t roundingMode;
-    union ui16_f16 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF16UI( uiA );
-    sigA = fracF16UI( uiA );
-    expB = expF16UI( uiB );
-    sigB = fracF16UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expA == 0x1F ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            uiZ = defaultNaNF16UI;
-            goto uiZ;
-        }
-        sigDiff = sigA - sigB;
-        if ( ! sigDiff ) {
-            uiZ =
-                packToF16UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-            goto uiZ;
-        }
-        if ( expA ) --expA;
-        signZ = signF16UI( uiA );
-        if ( sigDiff < 0 ) {
-            signZ = ! signZ;
-            sigDiff = -sigDiff;
-        }
-        shiftDist = softfloat_countLeadingZeros16( sigDiff ) - 5;
-        expZ = expA - shiftDist;
-        if ( expZ < 0 ) {
-            shiftDist = expA;
-            expZ = 0;
-        }
-        sigZ = sigDiff<<shiftDist;
-        goto pack;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signF16UI( uiA );
-        if ( expDiff < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            signZ = ! signZ;
-            if ( expB == 0x1F ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF16UI( signZ, 0x1F, 0 );
-                goto uiZ;
-            }
-            if ( expDiff <= -13 ) {
-                uiZ = packToF16UI( signZ, expB, sigB );
-                if ( expA | sigA ) goto subEpsilon;
-                goto uiZ;
-            }
-            expZ = expA + 19;
-            sigX = sigB | 0x0400;
-            sigY = sigA + (expA ? 0x0400 : sigA);
-            expDiff = -expDiff;
-        } else {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            uiZ = uiA;
-            if ( expA == 0x1F ) {
-                if ( sigA ) goto propagateNaN;
-                goto uiZ;
-            }
-            if ( 13 <= expDiff ) {
-                if ( expB | sigB ) goto subEpsilon;
-                goto uiZ;
-            }
-            expZ = expB + 19;
-            sigX = sigA | 0x0400;
-            sigY = sigB + (expB ? 0x0400 : sigB);
-        }
-        sig32Z = ((uint_fast32_t) sigX<<expDiff) - sigY;
-        shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1;
-        sig32Z <<= shiftDist;
-        expZ -= shiftDist;
-        sigZ = sig32Z>>16;
-        if ( sig32Z & 0xFFFF ) {
-            sigZ |= 1;
-        } else {
-            if ( ! (sigZ & 0xF) && ((unsigned int) expZ < 0x1E) ) {
-                sigZ >>= 4;
-                goto pack;
-            }
-        }
-        return softfloat_roundPackToF16( signZ, expZ, sigZ );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- subEpsilon:
-    roundingMode = softfloat_roundingMode;
-    if ( roundingMode != softfloat_round_near_even ) {
-        if (
-            (roundingMode == softfloat_round_minMag)
-                || (roundingMode
-                        == (signF16UI( uiZ ) ? softfloat_round_max
-                                : softfloat_round_min))
-        ) {
-            --uiZ;
-        }
-#ifdef SOFTFLOAT_ROUND_ODD
-        else if ( roundingMode == softfloat_round_odd ) {
-            uiZ = (uiZ - 1) | 1;
-        }
-#endif
-    }
-    softfloat_exceptionFlags |= softfloat_flag_inexact;
-    goto uiZ;
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- pack:
-    uiZ = packToF16UI( signZ, expZ, sigZ );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016, 2017 The Regents of the
+University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float16_t softfloat_subMagsF16( uint_fast16_t uiA, uint_fast16_t uiB )
+{
+    int_fast8_t expA;
+    uint_fast16_t sigA;
+    int_fast8_t expB;
+    uint_fast16_t sigB;
+    int_fast8_t expDiff;
+    uint_fast16_t uiZ;
+    int_fast16_t sigDiff;
+    bool signZ;
+    int_fast8_t shiftDist, expZ;
+    uint_fast16_t sigZ, sigX, sigY;
+    uint_fast32_t sig32Z;
+    int_fast8_t roundingMode;
+    union ui16_f16 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF16UI( uiA );
+    sigA = fracF16UI( uiA );
+    expB = expF16UI( uiB );
+    sigB = fracF16UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expA == 0x1F ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            uiZ = defaultNaNF16UI;
+            goto uiZ;
+        }
+        sigDiff = sigA - sigB;
+        if ( ! sigDiff ) {
+            uiZ =
+                packToF16UI(
+                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            goto uiZ;
+        }
+        if ( expA ) --expA;
+        signZ = signF16UI( uiA );
+        if ( sigDiff < 0 ) {
+            signZ = ! signZ;
+            sigDiff = -sigDiff;
+        }
+        shiftDist = softfloat_countLeadingZeros16( sigDiff ) - 5;
+        expZ = expA - shiftDist;
+        if ( expZ < 0 ) {
+            shiftDist = expA;
+            expZ = 0;
+        }
+        sigZ = sigDiff<<shiftDist;
+        goto pack;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signF16UI( uiA );
+        if ( expDiff < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            signZ = ! signZ;
+            if ( expB == 0x1F ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF16UI( signZ, 0x1F, 0 );
+                goto uiZ;
+            }
+            if ( expDiff <= -13 ) {
+                uiZ = packToF16UI( signZ, expB, sigB );
+                if ( expA | sigA ) goto subEpsilon;
+                goto uiZ;
+            }
+            expZ = expA + 19;
+            sigX = sigB | 0x0400;
+            sigY = sigA + (expA ? 0x0400 : sigA);
+            expDiff = -expDiff;
+        } else {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            uiZ = uiA;
+            if ( expA == 0x1F ) {
+                if ( sigA ) goto propagateNaN;
+                goto uiZ;
+            }
+            if ( 13 <= expDiff ) {
+                if ( expB | sigB ) goto subEpsilon;
+                goto uiZ;
+            }
+            expZ = expB + 19;
+            sigX = sigA | 0x0400;
+            sigY = sigB + (expB ? 0x0400 : sigB);
+        }
+        sig32Z = ((uint_fast32_t) sigX<<expDiff) - sigY;
+        shiftDist = softfloat_countLeadingZeros32( sig32Z ) - 1;
+        sig32Z <<= shiftDist;
+        expZ -= shiftDist;
+        sigZ = sig32Z>>16;
+        if ( sig32Z & 0xFFFF ) {
+            sigZ |= 1;
+        } else {
+            if ( ! (sigZ & 0xF) && ((unsigned int) expZ < 0x1E) ) {
+                sigZ >>= 4;
+                goto pack;
+            }
+        }
+        return softfloat_roundPackToF16( signZ, expZ, sigZ );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF16UI( uiA, uiB );
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ subEpsilon:
+    roundingMode = softfloat_roundingMode;
+    if ( roundingMode != softfloat_round_near_even ) {
+        if (
+            (roundingMode == softfloat_round_minMag)
+                || (roundingMode
+                        == (signF16UI( uiZ ) ? softfloat_round_max
+                                : softfloat_round_min))
+        ) {
+            --uiZ;
+        }
+#ifdef SOFTFLOAT_ROUND_ODD
+        else if ( roundingMode == softfloat_round_odd ) {
+            uiZ = (uiZ - 1) | 1;
+        }
+#endif
+    }
+    softfloat_exceptionFlags |= softfloat_flag_inexact;
+    goto uiZ;
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ pack:
+    uiZ = packToF16UI( signZ, expZ, sigZ );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_subMagsF32.c b/softfloat/source/s_subMagsF32.c
index 0c1f32e..8b3aee0 100644
--- a/softfloat/source/s_subMagsF32.c
+++ b/softfloat/source/s_subMagsF32.c
@@ -1,143 +1,143 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
-{
-    int_fast16_t expA;
-    uint_fast32_t sigA;
-    int_fast16_t expB;
-    uint_fast32_t sigB;
-    int_fast16_t expDiff;
-    uint_fast32_t uiZ;
-    int_fast32_t sigDiff;
-    bool signZ;
-    int_fast8_t shiftDist;
-    int_fast16_t expZ;
-    uint_fast32_t sigX, sigY;
-    union ui32_f32 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF32UI( uiA );
-    sigA = fracF32UI( uiA );
-    expB = expF32UI( uiB );
-    sigB = fracF32UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expA == 0xFF ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            uiZ = defaultNaNF32UI;
-            goto uiZ;
-        }
-        sigDiff = sigA - sigB;
-        if ( ! sigDiff ) {
-            uiZ =
-                packToF32UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-            goto uiZ;
-        }
-        if ( expA ) --expA;
-        signZ = signF32UI( uiA );
-        if ( sigDiff < 0 ) {
-            signZ = ! signZ;
-            sigDiff = -sigDiff;
-        }
-        shiftDist = softfloat_countLeadingZeros32( sigDiff ) - 8;
-        expZ = expA - shiftDist;
-        if ( expZ < 0 ) {
-            shiftDist = expA;
-            expZ = 0;
-        }
-        uiZ = packToF32UI( signZ, expZ, sigDiff<<shiftDist );
-        goto uiZ;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        signZ = signF32UI( uiA );
-        sigA <<= 7;
-        sigB <<= 7;
-        if ( expDiff < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            signZ = ! signZ;
-            if ( expB == 0xFF ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF32UI( signZ, 0xFF, 0 );
-                goto uiZ;
-            }
-            expZ = expB - 1;
-            sigX = sigB | 0x40000000;
-            sigY = sigA + (expA ? 0x40000000 : sigA);
-            expDiff = -expDiff;
-        } else {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            if ( expA == 0xFF ) {
-                if ( sigA ) goto propagateNaN;
-                uiZ = uiA;
-                goto uiZ;
-            }
-            expZ = expA - 1;
-            sigX = sigA | 0x40000000;
-            sigY = sigB + (expB ? 0x40000000 : sigB);
-        }
-        return
-            softfloat_normRoundPackToF32(
-                signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff )
-            );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float32_t softfloat_subMagsF32( uint_fast32_t uiA, uint_fast32_t uiB )
+{
+    int_fast16_t expA;
+    uint_fast32_t sigA;
+    int_fast16_t expB;
+    uint_fast32_t sigB;
+    int_fast16_t expDiff;
+    uint_fast32_t uiZ;
+    int_fast32_t sigDiff;
+    bool signZ;
+    int_fast8_t shiftDist;
+    int_fast16_t expZ;
+    uint_fast32_t sigX, sigY;
+    union ui32_f32 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF32UI( uiA );
+    sigA = fracF32UI( uiA );
+    expB = expF32UI( uiB );
+    sigB = fracF32UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expA == 0xFF ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            uiZ = defaultNaNF32UI;
+            goto uiZ;
+        }
+        sigDiff = sigA - sigB;
+        if ( ! sigDiff ) {
+            uiZ =
+                packToF32UI(
+                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            goto uiZ;
+        }
+        if ( expA ) --expA;
+        signZ = signF32UI( uiA );
+        if ( sigDiff < 0 ) {
+            signZ = ! signZ;
+            sigDiff = -sigDiff;
+        }
+        shiftDist = softfloat_countLeadingZeros32( sigDiff ) - 8;
+        expZ = expA - shiftDist;
+        if ( expZ < 0 ) {
+            shiftDist = expA;
+            expZ = 0;
+        }
+        uiZ = packToF32UI( signZ, expZ, sigDiff<<shiftDist );
+        goto uiZ;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        signZ = signF32UI( uiA );
+        sigA <<= 7;
+        sigB <<= 7;
+        if ( expDiff < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            signZ = ! signZ;
+            if ( expB == 0xFF ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF32UI( signZ, 0xFF, 0 );
+                goto uiZ;
+            }
+            expZ = expB - 1;
+            sigX = sigB | 0x40000000;
+            sigY = sigA + (expA ? 0x40000000 : sigA);
+            expDiff = -expDiff;
+        } else {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            if ( expA == 0xFF ) {
+                if ( sigA ) goto propagateNaN;
+                uiZ = uiA;
+                goto uiZ;
+            }
+            expZ = expA - 1;
+            sigX = sigA | 0x40000000;
+            sigY = sigB + (expB ? 0x40000000 : sigB);
+        }
+        return
+            softfloat_normRoundPackToF32(
+                signZ, expZ, sigX - softfloat_shiftRightJam32( sigY, expDiff )
+            );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF32UI( uiA, uiB );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_subMagsF64.c b/softfloat/source/s_subMagsF64.c
index a4a0ebc..3a4acb1 100644
--- a/softfloat/source/s_subMagsF64.c
+++ b/softfloat/source/s_subMagsF64.c
@@ -1,141 +1,141 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-float64_t
- softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
-{
-    int_fast16_t expA;
-    uint_fast64_t sigA;
-    int_fast16_t expB;
-    uint_fast64_t sigB;
-    int_fast16_t expDiff;
-    uint_fast64_t uiZ;
-    int_fast64_t sigDiff;
-    int_fast8_t shiftDist;
-    int_fast16_t expZ;
-    uint_fast64_t sigZ;
-    union ui64_f64 uZ;
-
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expA = expF64UI( uiA );
-    sigA = fracF64UI( uiA );
-    expB = expF64UI( uiB );
-    sigB = fracF64UI( uiB );
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
-    expDiff = expA - expB;
-    if ( ! expDiff ) {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        if ( expA == 0x7FF ) {
-            if ( sigA | sigB ) goto propagateNaN;
-            softfloat_raiseFlags( softfloat_flag_invalid );
-            uiZ = defaultNaNF64UI;
-            goto uiZ;
-        }
-        sigDiff = sigA - sigB;
-        if ( ! sigDiff ) {
-            uiZ =
-                packToF64UI(
-                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-            goto uiZ;
-        }
-        if ( expA ) --expA;
-        if ( sigDiff < 0 ) {
-            signZ = ! signZ;
-            sigDiff = -sigDiff;
-        }
-        shiftDist = softfloat_countLeadingZeros64( sigDiff ) - 11;
-        expZ = expA - shiftDist;
-        if ( expZ < 0 ) {
-            shiftDist = expA;
-            expZ = 0;
-        }
-        uiZ = packToF64UI( signZ, expZ, sigDiff<<shiftDist );
-        goto uiZ;
-    } else {
-        /*--------------------------------------------------------------------
-        *--------------------------------------------------------------------*/
-        sigA <<= 10;
-        sigB <<= 10;
-        if ( expDiff < 0 ) {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            signZ = ! signZ;
-            if ( expB == 0x7FF ) {
-                if ( sigB ) goto propagateNaN;
-                uiZ = packToF64UI( signZ, 0x7FF, 0 );
-                goto uiZ;
-            }
-            sigA += expA ? UINT64_C( 0x4000000000000000 ) : sigA;
-            sigA = softfloat_shiftRightJam64( sigA, -expDiff );
-            sigB |= UINT64_C( 0x4000000000000000 );
-            expZ = expB;
-            sigZ = sigB - sigA;
-        } else {
-            /*----------------------------------------------------------------
-            *----------------------------------------------------------------*/
-            if ( expA == 0x7FF ) {
-                if ( sigA ) goto propagateNaN;
-                uiZ = uiA;
-                goto uiZ;
-            }
-            sigB += expB ? UINT64_C( 0x4000000000000000 ) : sigB;
-            sigB = softfloat_shiftRightJam64( sigB, expDiff );
-            sigA |= UINT64_C( 0x4000000000000000 );
-            expZ = expA;
-            sigZ = sigA - sigB;
-        }
-        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
-    }
-    /*------------------------------------------------------------------------
-    *------------------------------------------------------------------------*/
- propagateNaN:
-    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
- uiZ:
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+float64_t
+ softfloat_subMagsF64( uint_fast64_t uiA, uint_fast64_t uiB, bool signZ )
+{
+    int_fast16_t expA;
+    uint_fast64_t sigA;
+    int_fast16_t expB;
+    uint_fast64_t sigB;
+    int_fast16_t expDiff;
+    uint_fast64_t uiZ;
+    int_fast64_t sigDiff;
+    int_fast8_t shiftDist;
+    int_fast16_t expZ;
+    uint_fast64_t sigZ;
+    union ui64_f64 uZ;
+
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expA = expF64UI( uiA );
+    sigA = fracF64UI( uiA );
+    expB = expF64UI( uiB );
+    sigB = fracF64UI( uiB );
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+    expDiff = expA - expB;
+    if ( ! expDiff ) {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        if ( expA == 0x7FF ) {
+            if ( sigA | sigB ) goto propagateNaN;
+            softfloat_raiseFlags( softfloat_flag_invalid );
+            uiZ = defaultNaNF64UI;
+            goto uiZ;
+        }
+        sigDiff = sigA - sigB;
+        if ( ! sigDiff ) {
+            uiZ =
+                packToF64UI(
+                    (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            goto uiZ;
+        }
+        if ( expA ) --expA;
+        if ( sigDiff < 0 ) {
+            signZ = ! signZ;
+            sigDiff = -sigDiff;
+        }
+        shiftDist = softfloat_countLeadingZeros64( sigDiff ) - 11;
+        expZ = expA - shiftDist;
+        if ( expZ < 0 ) {
+            shiftDist = expA;
+            expZ = 0;
+        }
+        uiZ = packToF64UI( signZ, expZ, sigDiff<<shiftDist );
+        goto uiZ;
+    } else {
+        /*--------------------------------------------------------------------
+        *--------------------------------------------------------------------*/
+        sigA <<= 10;
+        sigB <<= 10;
+        if ( expDiff < 0 ) {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            signZ = ! signZ;
+            if ( expB == 0x7FF ) {
+                if ( sigB ) goto propagateNaN;
+                uiZ = packToF64UI( signZ, 0x7FF, 0 );
+                goto uiZ;
+            }
+            sigA += expA ? UINT64_C( 0x4000000000000000 ) : sigA;
+            sigA = softfloat_shiftRightJam64( sigA, -expDiff );
+            sigB |= UINT64_C( 0x4000000000000000 );
+            expZ = expB;
+            sigZ = sigB - sigA;
+        } else {
+            /*----------------------------------------------------------------
+            *----------------------------------------------------------------*/
+            if ( expA == 0x7FF ) {
+                if ( sigA ) goto propagateNaN;
+                uiZ = uiA;
+                goto uiZ;
+            }
+            sigB += expB ? UINT64_C( 0x4000000000000000 ) : sigB;
+            sigB = softfloat_shiftRightJam64( sigB, expDiff );
+            sigA |= UINT64_C( 0x4000000000000000 );
+            expZ = expA;
+            sigZ = sigA - sigB;
+        }
+        return softfloat_normRoundPackToF64( signZ, expZ - 1, sigZ );
+    }
+    /*------------------------------------------------------------------------
+    *------------------------------------------------------------------------*/
+ propagateNaN:
+    uiZ = softfloat_propagateNaNF64UI( uiA, uiB );
+ uiZ:
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/s_tryPropagateNaNExtF80M.c b/softfloat/source/s_tryPropagateNaNExtF80M.c
index 70092fe..de6532e 100644
--- a/softfloat/source/s_tryPropagateNaNExtF80M.c
+++ b/softfloat/source/s_tryPropagateNaNExtF80M.c
@@ -1,64 +1,64 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-bool
- softfloat_tryPropagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- )
-{
-    uint_fast16_t ui64;
-    uint64_t ui0;
-
-    ui64 = aSPtr->signExp;
-    ui0  = aSPtr->signif;
-    if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN;
-    ui64 = bSPtr->signExp;
-    ui0  = bSPtr->signif;
-    if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN;
-    return false;
- propagateNaN:
-    softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr );
-    return true;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+bool
+ softfloat_tryPropagateNaNExtF80M(
+     const struct extFloat80M *aSPtr,
+     const struct extFloat80M *bSPtr,
+     struct extFloat80M *zSPtr
+ )
+{
+    uint_fast16_t ui64;
+    uint64_t ui0;
+
+    ui64 = aSPtr->signExp;
+    ui0  = aSPtr->signif;
+    if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN;
+    ui64 = bSPtr->signExp;
+    ui0  = bSPtr->signif;
+    if ( isNaNExtF80UI( ui64, ui0 ) ) goto propagateNaN;
+    return false;
+ propagateNaN:
+    softfloat_propagateNaNExtF80M( aSPtr, bSPtr, zSPtr );
+    return true;
+
+}
+
diff --git a/softfloat/source/s_tryPropagateNaNF128M.c b/softfloat/source/s_tryPropagateNaNF128M.c
index bab04a7..57199d9 100644
--- a/softfloat/source/s_tryPropagateNaNF128M.c
+++ b/softfloat/source/s_tryPropagateNaNF128M.c
@@ -1,55 +1,55 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdbool.h>
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-
-bool
- softfloat_tryPropagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
-{
-
-    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
-        softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr );
-        return true;
-    }
-    return false;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdbool.h>
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+
+bool
+ softfloat_tryPropagateNaNF128M(
+     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr )
+{
+
+    if ( softfloat_isNaNF128M( aWPtr ) || softfloat_isNaNF128M( bWPtr ) ) {
+        softfloat_propagateNaNF128M( aWPtr, bWPtr, zWPtr );
+        return true;
+    }
+    return false;
+
+}
+
diff --git a/softfloat/source/softfloat_state.c b/softfloat/source/softfloat_state.c
index 0f29665..277d76f 100644
--- a/softfloat/source/softfloat_state.c
+++ b/softfloat/source/softfloat_state.c
@@ -1,52 +1,52 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "specialize.h"
-#include "softfloat.h"
-
-#ifndef THREAD_LOCAL
-#define THREAD_LOCAL
-#endif
-
-THREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even;
-THREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess;
-THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags = 0;
-
-THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "specialize.h"
+#include "softfloat.h"
+
+#ifndef THREAD_LOCAL
+#define THREAD_LOCAL
+#endif
+
+THREAD_LOCAL uint_fast8_t softfloat_roundingMode = softfloat_round_near_even;
+THREAD_LOCAL uint_fast8_t softfloat_detectTininess = init_detectTininess;
+THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags = 0;
+
+THREAD_LOCAL uint_fast8_t extF80_roundingPrecision = 80;
+
diff --git a/softfloat/source/ui32_to_extF80.c b/softfloat/source/ui32_to_extF80.c
index 34f7936..dbb35c7 100644
--- a/softfloat/source/ui32_to_extF80.c
+++ b/softfloat/source/ui32_to_extF80.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t ui32_to_extF80( uint32_t a )
-{
-    uint_fast16_t uiZ64;
-    int_fast8_t shiftDist;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    uiZ64 = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros32( a );
-        uiZ64 = 0x401E - shiftDist;
-        a <<= shiftDist;
-    }
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif = (uint_fast64_t) a<<32;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t ui32_to_extF80( uint32_t a )
+{
+    uint_fast16_t uiZ64;
+    int_fast8_t shiftDist;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    uiZ64 = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros32( a );
+        uiZ64 = 0x401E - shiftDist;
+        a <<= shiftDist;
+    }
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif = (uint_fast64_t) a<<32;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/ui32_to_extF80M.c b/softfloat/source/ui32_to_extF80M.c
index 0a0c098..ec2396e 100644
--- a/softfloat/source/ui32_to_extF80M.c
+++ b/softfloat/source/ui32_to_extF80M.c
@@ -1,74 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = ui32_to_extF80( a );
-
-}
-
-#else
-
-void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiZ64;
-    uint64_t sigZ;
-    int_fast8_t shiftDist;
-
-    zSPtr = (struct extFloat80M *) zPtr;
-    uiZ64 = 0;
-    sigZ = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros32( a );
-        uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist );
-        sigZ = (uint64_t) (a<<shiftDist)<<32;
-    }
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = sigZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = ui32_to_extF80( a );
+
+}
+
+#else
+
+void ui32_to_extF80M( uint32_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiZ64;
+    uint64_t sigZ;
+    int_fast8_t shiftDist;
+
+    zSPtr = (struct extFloat80M *) zPtr;
+    uiZ64 = 0;
+    sigZ = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros32( a );
+        uiZ64 = packToExtF80UI64( 0, 0x401E - shiftDist );
+        sigZ = (uint64_t) (a<<shiftDist)<<32;
+    }
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = sigZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/ui32_to_f128.c b/softfloat/source/ui32_to_f128.c
index c3ab53d..8dcf2eb 100644
--- a/softfloat/source/ui32_to_f128.c
+++ b/softfloat/source/ui32_to_f128.c
@@ -1,60 +1,60 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t ui32_to_f128( uint32_t a )
-{
-    uint_fast64_t uiZ64;
-    int_fast8_t shiftDist;
-    union ui128_f128 uZ;
-
-    uiZ64 = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros32( a ) + 17;
-        uiZ64 =
-            packToF128UI64(
-                0, 0x402E - shiftDist, (uint_fast64_t) a<<shiftDist );
-    }
-    uZ.ui.v64 = uiZ64;
-    uZ.ui.v0  = 0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t ui32_to_f128( uint32_t a )
+{
+    uint_fast64_t uiZ64;
+    int_fast8_t shiftDist;
+    union ui128_f128 uZ;
+
+    uiZ64 = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros32( a ) + 17;
+        uiZ64 =
+            packToF128UI64(
+                0, 0x402E - shiftDist, (uint_fast64_t) a<<shiftDist );
+    }
+    uZ.ui.v64 = uiZ64;
+    uZ.ui.v0  = 0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/ui32_to_f128M.c b/softfloat/source/ui32_to_f128M.c
index 02b0434..8d4ff43 100644
--- a/softfloat/source/ui32_to_f128M.c
+++ b/softfloat/source/ui32_to_f128M.c
@@ -1,76 +1,76 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void ui32_to_f128M( uint32_t a, float128_t *zPtr )
-{
-
-    *zPtr = ui32_to_f128( a );
-
-}
-
-#else
-
-void ui32_to_f128M( uint32_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr, uiZ96, uiZ64;
-    int_fast8_t shiftDist;
-    uint64_t normA;
-
-    zWPtr = (uint32_t *) zPtr;
-    uiZ96 = 0;
-    uiZ64 = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros32( a ) + 17;
-        normA = (uint64_t) a<<shiftDist;
-        uiZ96 = packToF128UI96( 0, 0x402E - shiftDist, normA>>32 );
-        uiZ64 = normA;
-    }
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = uiZ64;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void ui32_to_f128M( uint32_t a, float128_t *zPtr )
+{
+
+    *zPtr = ui32_to_f128( a );
+
+}
+
+#else
+
+void ui32_to_f128M( uint32_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr, uiZ96, uiZ64;
+    int_fast8_t shiftDist;
+    uint64_t normA;
+
+    zWPtr = (uint32_t *) zPtr;
+    uiZ96 = 0;
+    uiZ64 = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros32( a ) + 17;
+        normA = (uint64_t) a<<shiftDist;
+        uiZ96 = packToF128UI96( 0, 0x402E - shiftDist, normA>>32 );
+        uiZ64 = normA;
+    }
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = uiZ64;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+
+}
+
+#endif
+
diff --git a/softfloat/source/ui32_to_f16.c b/softfloat/source/ui32_to_f16.c
index 6fc377b..a923f22 100644
--- a/softfloat/source/ui32_to_f16.c
+++ b/softfloat/source/ui32_to_f16.c
@@ -1,65 +1,65 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t ui32_to_f16( uint32_t a )
-{
-    int_fast8_t shiftDist;
-    union ui16_f16 u;
-    uint_fast16_t sig;
-
-    shiftDist = softfloat_countLeadingZeros32( a ) - 21;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF16UI(
-                    0, 0x18 - shiftDist, (uint_fast16_t) a<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 4;
-        sig =
-            (shiftDist < 0)
-                ? a>>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)
-                : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t ui32_to_f16( uint32_t a )
+{
+    int_fast8_t shiftDist;
+    union ui16_f16 u;
+    uint_fast16_t sig;
+
+    shiftDist = softfloat_countLeadingZeros32( a ) - 21;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF16UI(
+                    0, 0x18 - shiftDist, (uint_fast16_t) a<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 4;
+        sig =
+            (shiftDist < 0)
+                ? a>>(-shiftDist) | ((uint32_t) (a<<(shiftDist & 31)) != 0)
+                : (uint_fast16_t) a<<shiftDist;
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/ui32_to_f32.c b/softfloat/source/ui32_to_f32.c
index d75911f..e74ee7b 100644
--- a/softfloat/source/ui32_to_f32.c
+++ b/softfloat/source/ui32_to_f32.c
@@ -1,57 +1,57 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t ui32_to_f32( uint32_t a )
-{
-    union ui32_f32 uZ;
-
-    if ( ! a ) {
-        uZ.ui = 0;
-        return uZ.f;
-    }
-    if ( a & 0x80000000 ) {
-        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );
-    } else {
-        return softfloat_normRoundPackToF32( 0, 0x9C, a );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t ui32_to_f32( uint32_t a )
+{
+    union ui32_f32 uZ;
+
+    if ( ! a ) {
+        uZ.ui = 0;
+        return uZ.f;
+    }
+    if ( a & 0x80000000 ) {
+        return softfloat_roundPackToF32( 0, 0x9D, a>>1 | (a & 1) );
+    } else {
+        return softfloat_normRoundPackToF32( 0, 0x9C, a );
+    }
+
+}
+
diff --git a/softfloat/source/ui32_to_f64.c b/softfloat/source/ui32_to_f64.c
index 504f96e..11050c1 100644
--- a/softfloat/source/ui32_to_f64.c
+++ b/softfloat/source/ui32_to_f64.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t ui32_to_f64( uint32_t a )
-{
-    uint_fast64_t uiZ;
-    int_fast8_t shiftDist;
-    union ui64_f64 uZ;
-
-    if ( ! a ) {
-        uiZ = 0;
-    } else {
-        shiftDist = softfloat_countLeadingZeros32( a ) + 21;
-        uiZ =
-            packToF64UI( 0, 0x432 - shiftDist, (uint_fast64_t) a<<shiftDist );
-    }
-    uZ.ui = uiZ;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t ui32_to_f64( uint32_t a )
+{
+    uint_fast64_t uiZ;
+    int_fast8_t shiftDist;
+    union ui64_f64 uZ;
+
+    if ( ! a ) {
+        uiZ = 0;
+    } else {
+        shiftDist = softfloat_countLeadingZeros32( a ) + 21;
+        uiZ =
+            packToF64UI( 0, 0x432 - shiftDist, (uint_fast64_t) a<<shiftDist );
+    }
+    uZ.ui = uiZ;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/ui64_to_extF80.c b/softfloat/source/ui64_to_extF80.c
index b0e932f..7fcf140 100644
--- a/softfloat/source/ui64_to_extF80.c
+++ b/softfloat/source/ui64_to_extF80.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-extFloat80_t ui64_to_extF80( uint64_t a )
-{
-    uint_fast16_t uiZ64;
-    int_fast8_t shiftDist;
-    union { struct extFloat80M s; extFloat80_t f; } uZ;
-
-    uiZ64 = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros64( a );
-        uiZ64 = 0x403E - shiftDist;
-        a <<= shiftDist;
-    }
-    uZ.s.signExp = uiZ64;
-    uZ.s.signif  = a;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+extFloat80_t ui64_to_extF80( uint64_t a )
+{
+    uint_fast16_t uiZ64;
+    int_fast8_t shiftDist;
+    union { struct extFloat80M s; extFloat80_t f; } uZ;
+
+    uiZ64 = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros64( a );
+        uiZ64 = 0x403E - shiftDist;
+        a <<= shiftDist;
+    }
+    uZ.s.signExp = uiZ64;
+    uZ.s.signif  = a;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/ui64_to_extF80M.c b/softfloat/source/ui64_to_extF80M.c
index e676d90..9662884 100644
--- a/softfloat/source/ui64_to_extF80M.c
+++ b/softfloat/source/ui64_to_extF80M.c
@@ -1,74 +1,74 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
-{
-
-    *zPtr = ui64_to_extF80( a );
-
-}
-
-#else
-
-void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
-{
-    struct extFloat80M *zSPtr;
-    uint_fast16_t uiZ64;
-    uint64_t sigZ;
-    int_fast8_t shiftDist;
-
-    zSPtr = (struct extFloat80M *) zPtr;
-    uiZ64 = 0;
-    sigZ = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros64( a );
-        uiZ64 = packToExtF80UI64( 0, 0x403E - shiftDist );
-        sigZ = a<<shiftDist;
-    }
-    zSPtr->signExp = uiZ64;
-    zSPtr->signif = sigZ;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
+{
+
+    *zPtr = ui64_to_extF80( a );
+
+}
+
+#else
+
+void ui64_to_extF80M( uint64_t a, extFloat80_t *zPtr )
+{
+    struct extFloat80M *zSPtr;
+    uint_fast16_t uiZ64;
+    uint64_t sigZ;
+    int_fast8_t shiftDist;
+
+    zSPtr = (struct extFloat80M *) zPtr;
+    uiZ64 = 0;
+    sigZ = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros64( a );
+        uiZ64 = packToExtF80UI64( 0, 0x403E - shiftDist );
+        sigZ = a<<shiftDist;
+    }
+    zSPtr->signExp = uiZ64;
+    zSPtr->signif = sigZ;
+
+}
+
+#endif
+
diff --git a/softfloat/source/ui64_to_f128.c b/softfloat/source/ui64_to_f128.c
index 6ff6a6f..c2c1ce3 100644
--- a/softfloat/source/ui64_to_f128.c
+++ b/softfloat/source/ui64_to_f128.c
@@ -1,68 +1,68 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float128_t ui64_to_f128( uint64_t a )
-{
-    uint_fast64_t uiZ64, uiZ0;
-    int_fast8_t shiftDist;
-    struct uint128 zSig;
-    union ui128_f128 uZ;
-
-    if ( ! a ) {
-        uiZ64 = 0;
-        uiZ0  = 0;
-    } else {
-        shiftDist = softfloat_countLeadingZeros64( a ) + 49;
-        if ( 64 <= shiftDist ) {
-            zSig.v64 = a<<(shiftDist - 64);
-            zSig.v0  = 0;
-        } else {
-            zSig = softfloat_shortShiftLeft128( 0, a, shiftDist );
-        }
-        uiZ64 = packToF128UI64( 0, 0x406E - shiftDist, zSig.v64 );
-        uiZ0  = zSig.v0;
-    }
-    uZ.ui.v64 = uiZ64;
-    uZ.ui.v0  = uiZ0;
-    return uZ.f;
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float128_t ui64_to_f128( uint64_t a )
+{
+    uint_fast64_t uiZ64, uiZ0;
+    int_fast8_t shiftDist;
+    struct uint128 zSig;
+    union ui128_f128 uZ;
+
+    if ( ! a ) {
+        uiZ64 = 0;
+        uiZ0  = 0;
+    } else {
+        shiftDist = softfloat_countLeadingZeros64( a ) + 49;
+        if ( 64 <= shiftDist ) {
+            zSig.v64 = a<<(shiftDist - 64);
+            zSig.v0  = 0;
+        } else {
+            zSig = softfloat_shortShiftLeft128( 0, a, shiftDist );
+        }
+        uiZ64 = packToF128UI64( 0, 0x406E - shiftDist, zSig.v64 );
+        uiZ0  = zSig.v0;
+    }
+    uZ.ui.v64 = uiZ64;
+    uZ.ui.v0  = uiZ0;
+    return uZ.f;
+
+}
+
diff --git a/softfloat/source/ui64_to_f128M.c b/softfloat/source/ui64_to_f128M.c
index 043406c..2475304 100644
--- a/softfloat/source/ui64_to_f128M.c
+++ b/softfloat/source/ui64_to_f128M.c
@@ -1,86 +1,86 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-#ifdef SOFTFLOAT_FAST_INT64
-
-void ui64_to_f128M( uint64_t a, float128_t *zPtr )
-{
-
-    *zPtr = ui64_to_f128( a );
-
-}
-
-#else
-
-void ui64_to_f128M( uint64_t a, float128_t *zPtr )
-{
-    uint32_t *zWPtr, uiZ96, uiZ64;
-    uint_fast8_t shiftDist;
-    uint32_t *ptr;
-
-    zWPtr = (uint32_t *) zPtr;
-    uiZ96 = 0;
-    uiZ64 = 0;
-    zWPtr[indexWord( 4, 1 )] = 0;
-    zWPtr[indexWord( 4, 0 )] = 0;
-    if ( a ) {
-        shiftDist = softfloat_countLeadingZeros64( a ) + 17;
-        if ( shiftDist < 32 ) {
-            ptr = zWPtr + indexMultiwordHi( 4, 3 );
-            ptr[indexWord( 3, 2 )] = 0;
-            ptr[indexWord( 3, 1 )] = a>>32;
-            ptr[indexWord( 3, 0 )] = a;
-            softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
-            ptr[indexWordHi( 3 )] =
-                packToF128UI96( 0, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );
-            return;
-        }
-        a <<= shiftDist - 32;
-        uiZ96 = packToF128UI96( 0, 0x404E - shiftDist, a>>32 );
-        uiZ64 = a;
-    }
-    zWPtr[indexWord( 4, 3 )] = uiZ96;
-    zWPtr[indexWord( 4, 2 )] = uiZ64;
-
-}
-
-#endif
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+#ifdef SOFTFLOAT_FAST_INT64
+
+void ui64_to_f128M( uint64_t a, float128_t *zPtr )
+{
+
+    *zPtr = ui64_to_f128( a );
+
+}
+
+#else
+
+void ui64_to_f128M( uint64_t a, float128_t *zPtr )
+{
+    uint32_t *zWPtr, uiZ96, uiZ64;
+    uint_fast8_t shiftDist;
+    uint32_t *ptr;
+
+    zWPtr = (uint32_t *) zPtr;
+    uiZ96 = 0;
+    uiZ64 = 0;
+    zWPtr[indexWord( 4, 1 )] = 0;
+    zWPtr[indexWord( 4, 0 )] = 0;
+    if ( a ) {
+        shiftDist = softfloat_countLeadingZeros64( a ) + 17;
+        if ( shiftDist < 32 ) {
+            ptr = zWPtr + indexMultiwordHi( 4, 3 );
+            ptr[indexWord( 3, 2 )] = 0;
+            ptr[indexWord( 3, 1 )] = a>>32;
+            ptr[indexWord( 3, 0 )] = a;
+            softfloat_shortShiftLeft96M( ptr, shiftDist, ptr );
+            ptr[indexWordHi( 3 )] =
+                packToF128UI96( 0, 0x404E - shiftDist, ptr[indexWordHi( 3 )] );
+            return;
+        }
+        a <<= shiftDist - 32;
+        uiZ96 = packToF128UI96( 0, 0x404E - shiftDist, a>>32 );
+        uiZ64 = a;
+    }
+    zWPtr[indexWord( 4, 3 )] = uiZ96;
+    zWPtr[indexWord( 4, 2 )] = uiZ64;
+
+}
+
+#endif
+
diff --git a/softfloat/source/ui64_to_f16.c b/softfloat/source/ui64_to_f16.c
index 3d58e85..9ff6e17 100644
--- a/softfloat/source/ui64_to_f16.c
+++ b/softfloat/source/ui64_to_f16.c
@@ -1,64 +1,64 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float16_t ui64_to_f16( uint64_t a )
-{
-    int_fast8_t shiftDist;
-    union ui16_f16 u;
-    uint_fast16_t sig;
-
-    shiftDist = softfloat_countLeadingZeros64( a ) - 53;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF16UI(
-                    0, 0x18 - shiftDist, (uint_fast16_t) a<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 4;
-        sig =
-            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
-                : (uint_fast16_t) a<<shiftDist;
-        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float16_t ui64_to_f16( uint64_t a )
+{
+    int_fast8_t shiftDist;
+    union ui16_f16 u;
+    uint_fast16_t sig;
+
+    shiftDist = softfloat_countLeadingZeros64( a ) - 53;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF16UI(
+                    0, 0x18 - shiftDist, (uint_fast16_t) a<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 4;
+        sig =
+            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
+                : (uint_fast16_t) a<<shiftDist;
+        return softfloat_roundPackToF16( 0, 0x1C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/ui64_to_f32.c b/softfloat/source/ui64_to_f32.c
index cbe3a9d..9065b92 100644
--- a/softfloat/source/ui64_to_f32.c
+++ b/softfloat/source/ui64_to_f32.c
@@ -1,64 +1,64 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
-California.  All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float32_t ui64_to_f32( uint64_t a )
-{
-    int_fast8_t shiftDist;
-    union ui32_f32 u;
-    uint_fast32_t sig;
-
-    shiftDist = softfloat_countLeadingZeros64( a ) - 40;
-    if ( 0 <= shiftDist ) {
-        u.ui =
-            a ? packToF32UI(
-                    0, 0x95 - shiftDist, (uint_fast32_t) a<<shiftDist )
-                : 0;
-        return u.f;
-    } else {
-        shiftDist += 7;
-        sig =
-            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
-                : (uint_fast32_t) a<<shiftDist;
-        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014, 2015, 2016 The Regents of the University of
+California.  All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float32_t ui64_to_f32( uint64_t a )
+{
+    int_fast8_t shiftDist;
+    union ui32_f32 u;
+    uint_fast32_t sig;
+
+    shiftDist = softfloat_countLeadingZeros64( a ) - 40;
+    if ( 0 <= shiftDist ) {
+        u.ui =
+            a ? packToF32UI(
+                    0, 0x95 - shiftDist, (uint_fast32_t) a<<shiftDist )
+                : 0;
+        return u.f;
+    } else {
+        shiftDist += 7;
+        sig =
+            (shiftDist < 0) ? softfloat_shortShiftRightJam64( a, -shiftDist )
+                : (uint_fast32_t) a<<shiftDist;
+        return softfloat_roundPackToF32( 0, 0x9C - shiftDist, sig );
+    }
+
+}
+
diff --git a/softfloat/source/ui64_to_f64.c b/softfloat/source/ui64_to_f64.c
index 0328943..4693086 100644
--- a/softfloat/source/ui64_to_f64.c
+++ b/softfloat/source/ui64_to_f64.c
@@ -1,59 +1,59 @@
-
-/*============================================================================
-
-This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
-Package, Release 3e, by John R. Hauser.
-
-Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
-All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- 1. Redistributions of source code must retain the above copyright notice,
-    this list of conditions, and the following disclaimer.
-
- 2. Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions, and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-
- 3. Neither the name of the University nor the names of its contributors may
-    be used to endorse or promote products derived from this software without
-    specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
-EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
-DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-=============================================================================*/
-
-#include <stdint.h>
-#include "platform.h"
-#include "internals.h"
-#include "softfloat.h"
-
-float64_t ui64_to_f64( uint64_t a )
-{
-    union ui64_f64 uZ;
-
-    if ( ! a ) {
-        uZ.ui = 0;
-        return uZ.f;
-    }
-    if ( a & UINT64_C( 0x8000000000000000 ) ) {
-        return
-            softfloat_roundPackToF64(
-                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );
-    } else {
-        return softfloat_normRoundPackToF64( 0, 0x43C, a );
-    }
-
-}
-
+
+/*============================================================================
+
+This C source file is part of the SoftFloat IEEE Floating-Point Arithmetic
+Package, Release 3e, by John R. Hauser.
+
+Copyright 2011, 2012, 2013, 2014 The Regents of the University of California.
+All Rights Reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions, and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions, and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+ 3. Neither the name of the University nor the names of its contributors may
+    be used to endorse or promote products derived from this software without
+    specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS "AS IS", AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE, ARE
+DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=============================================================================*/
+
+#include <stdint.h>
+#include "platform.h"
+#include "internals.h"
+#include "softfloat.h"
+
+float64_t ui64_to_f64( uint64_t a )
+{
+    union ui64_f64 uZ;
+
+    if ( ! a ) {
+        uZ.ui = 0;
+        return uZ.f;
+    }
+    if ( a & UINT64_C( 0x8000000000000000 ) ) {
+        return
+            softfloat_roundPackToF64(
+                0, 0x43D, softfloat_shortShiftRightJam64( a, 1 ) );
+    } else {
+        return softfloat_normRoundPackToF64( 0, 0x43C, a );
+    }
+
+}
+

From 93d89e07ca0799d190501e51e9ad16dafa38e060 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 29 Jul 2024 17:22:12 +0200
Subject: [PATCH 052/100] removes wrong compile definition

---
 softfloat/CMakeLists.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/softfloat/CMakeLists.txt b/softfloat/CMakeLists.txt
index fa2cc62..b5766c6 100644
--- a/softfloat/CMakeLists.txt
+++ b/softfloat/CMakeLists.txt
@@ -335,7 +335,6 @@ target_compile_definitions(softfloat PRIVATE
 	SOFTFLOAT_FAST_DIV32TO16
   	SOFTFLOAT_FAST_DIV64TO32
   	SOFTFLOAT_FAST_INT64
-	__GNUC_STDC_INLINE__=1
 #  	THREAD_LOCAL=__thread
 )
 target_include_directories(softfloat PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/build/Linux-x86_64-GCC)

From 7ffa7667b6f31d27cda7c2c15a7e330055eb0385 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 29 Jul 2024 21:07:54 +0200
Subject: [PATCH 053/100] fixes concerning FMADD_S, FMSUB_S, FNMADD_S, and
 FNSUB_S mostly about ensuring correct sign

---
 softfloat/source/s_mulAddF32.c | 8 ++++++--
 src/vm/fp_functions.cpp        | 8 +++++++-
 2 files changed, 13 insertions(+), 3 deletions(-)

diff --git a/softfloat/source/s_mulAddF32.c b/softfloat/source/s_mulAddF32.c
index 805517c..94c21eb 100644
--- a/softfloat/source/s_mulAddF32.c
+++ b/softfloat/source/s_mulAddF32.c
@@ -92,11 +92,14 @@ float32_t
         goto infProdArg;
     }
     if ( expC == 0xFF ) {
+        // expC indicates special value
         if ( sigC ) {
+            //uiC is quiet NaN
             uiZ = 0;
             goto propagateNaN_ZC;
         }
-        uiZ = uiC;
+        //uiC is +- infinity
+        uiZ =  (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
         goto uiZ;
     }
     /*------------------------------------------------------------------------
@@ -209,12 +212,13 @@ float32_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  zeroProd:
-    uiZ = uiC;
+    uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
     if ( ! (expC | sigC) && (signProd != signC) ) {
  completeCancellation:
         uiZ =
             packToF32UI(
                 (softfloat_roundingMode == softfloat_round_min), 0, 0 );
+    uiZ = (uiZ & ~(1UL << 31)) | ((unsigned long)(signC|signProd) << 31); //set sign bit            
     }
  uiZ:
     uZ.ui = uiZ;
diff --git a/src/vm/fp_functions.cpp b/src/vm/fp_functions.cpp
index cad3b06..ad340b5 100644
--- a/src/vm/fp_functions.cpp
+++ b/src/vm/fp_functions.cpp
@@ -149,11 +149,17 @@ uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
 }
 
 uint32_t fmadd_s(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mode) {
+    // Used values for op are:
+    // FMADD_S:  0b00
+    // FMSUB_S:  0b01
+    // FNMADD_S: 0b10
+    // FNMSUB_S: 0b11
     // op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
     softfloat_roundingMode = rmm_map[mode & 0x7];
     softfloat_exceptionFlags = 0;
     float32_t res = softfloat_mulAddF32(v1, v2, v3, op & 0x1);
-    if(op > 1)
+    // Do not invert quiet NaN
+    if((op & 0b10) && (res.v != quiet_nan32))
         res.v ^= 1ULL << 31;
     return res.v;
 }

From 2edd68d1bdadd2bd46c3fdc176b2b5e861eea051 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 30 Jul 2024 12:02:40 +0200
Subject: [PATCH 054/100] refactors zeroProd branch to allow for better case
 handling

---
 softfloat/source/s_mulAddF32.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/softfloat/source/s_mulAddF32.c b/softfloat/source/s_mulAddF32.c
index 94c21eb..f324642 100644
--- a/softfloat/source/s_mulAddF32.c
+++ b/softfloat/source/s_mulAddF32.c
@@ -212,13 +212,18 @@ float32_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  zeroProd:
-    uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
-    if ( ! (expC | sigC) && (signProd != signC) ) {
- completeCancellation:
-        uiZ =
-            packToF32UI(
-                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
-    uiZ = (uiZ & ~(1UL << 31)) | ((unsigned long)(signC|signProd) << 31); //set sign bit            
+    if(expC | sigC){
+        //3rd operand != 0
+        uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)(signC) << 31); //set sign bit   
+    }
+    else {
+        //3rd operand == +-0
+        if (signProd != signC) {
+            completeCancellation:
+            uiZ = packToF32UI((softfloat_roundingMode == softfloat_round_min), 0, 0 );
+            goto uiZ;     
+        }
+        uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
     }
  uiZ:
     uZ.ui = uiZ;

From 5d69b792328e33a14bdbb9a8faa246fd3d373154 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 30 Jul 2024 13:30:21 +0200
Subject: [PATCH 055/100] reverts patches in softfloat

---
 softfloat/source/s_mulAddF32.c | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

diff --git a/softfloat/source/s_mulAddF32.c b/softfloat/source/s_mulAddF32.c
index f324642..5c9cb59 100644
--- a/softfloat/source/s_mulAddF32.c
+++ b/softfloat/source/s_mulAddF32.c
@@ -92,14 +92,11 @@ float32_t
         goto infProdArg;
     }
     if ( expC == 0xFF ) {
-        // expC indicates special value
         if ( sigC ) {
-            //uiC is quiet NaN
             uiZ = 0;
             goto propagateNaN_ZC;
         }
-        //uiC is +- infinity
-        uiZ =  (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
+        uiZ = uiC;
         goto uiZ;
     }
     /*------------------------------------------------------------------------
@@ -212,22 +209,15 @@ float32_t
     /*------------------------------------------------------------------------
     *------------------------------------------------------------------------*/
  zeroProd:
-    if(expC | sigC){
-        //3rd operand != 0
-        uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)(signC) << 31); //set sign bit   
-    }
-    else {
-        //3rd operand == +-0
-        if (signProd != signC) {
-            completeCancellation:
-            uiZ = packToF32UI((softfloat_roundingMode == softfloat_round_min), 0, 0 );
-            goto uiZ;     
-        }
-        uiZ = (uiC & ~(1UL << 31)) | ((unsigned long)signC << 31); //set sign bit
+    uiZ = uiC;
+    if ( ! (expC | sigC) && (signProd != signC) ) {
+ completeCancellation:
+        uiZ =
+            packToF32UI(
+                (softfloat_roundingMode == softfloat_round_min), 0, 0 );
     }
  uiZ:
     uZ.ui = uiZ;
     return uZ.f;
 
 }
-

From fd20e66f1fc2923674aeb2bd7a6371948cc33cea Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 30 Jul 2024 13:31:00 +0200
Subject: [PATCH 056/100] changes softfloat API usage, all effected Instrs pass
 test suite

---
 src/vm/fp_functions.cpp | 26 ++++++++++++++++----------
 1 file changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/vm/fp_functions.cpp b/src/vm/fp_functions.cpp
index ad340b5..3a87ae3 100644
--- a/src/vm/fp_functions.cpp
+++ b/src/vm/fp_functions.cpp
@@ -149,18 +149,24 @@ uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
 }
 
 uint32_t fmadd_s(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mode) {
-    // Used values for op are:
-    // FMADD_S:  0b00
-    // FMSUB_S:  0b01
-    // FNMADD_S: 0b10
-    // FNMSUB_S: 0b11
-    // op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
+    uint32_t F32_SIGN = 1UL << 31;
+    switch(op) {
+    case 0: // FMADD_S
+        break;
+    case 1: // FMSUB_S
+        v3 ^= F32_SIGN;
+        break;
+    case 2: // FNMADD_S
+        v1 ^= F32_SIGN;
+        v3 ^= F32_SIGN;
+        break;
+    case 3: // FNMSUB_S
+        v1 ^= F32_SIGN;
+        break;
+    }
     softfloat_roundingMode = rmm_map[mode & 0x7];
     softfloat_exceptionFlags = 0;
-    float32_t res = softfloat_mulAddF32(v1, v2, v3, op & 0x1);
-    // Do not invert quiet NaN
-    if((op & 0b10) && (res.v != quiet_nan32))
-        res.v ^= 1ULL << 31;
+    float32_t res = softfloat_mulAddF32(v1, v2, v3, 0);
     return res.v;
 }
 

From f579ec6e489d05e0633380b71804758f01e358c0 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 31 Jul 2024 12:20:25 +0200
Subject: [PATCH 057/100] changes access to rounding mode to fail explicitly
 instead of unintended behavior

---
 src/vm/fp_functions.cpp | 63 +++++++++++++++++++++--------------------
 1 file changed, 33 insertions(+), 30 deletions(-)

diff --git a/src/vm/fp_functions.cpp b/src/vm/fp_functions.cpp
index 3a87ae3..865ee64 100644
--- a/src/vm/fp_functions.cpp
+++ b/src/vm/fp_functions.cpp
@@ -33,6 +33,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 #include "fp_functions.h"
+#include <array>
 
 extern "C" {
 #include "internals.h"
@@ -43,9 +44,10 @@ extern "C" {
 #include <limits>
 
 using this_t = uint8_t*;
-const uint8_t rmm_map[] = {
-    softfloat_round_near_even /*RNE*/,   softfloat_round_minMag /*RTZ*/, softfloat_round_min /*RDN*/, softfloat_round_max /*RUP?*/,
-    softfloat_round_near_maxMag /*RMM*/, softfloat_round_max /*RTZ*/,    softfloat_round_max /*RTZ*/, softfloat_round_max /*RTZ*/,
+// this does not inlcude any reserved rm or the DYN rm, as DYN rm should be taken care of in the vm_impl
+const std::array<uint8_t, 5> rmm_map = {
+    softfloat_round_near_even /*RNE*/, softfloat_round_minMag /*RTZ*/, softfloat_round_min /*RDN*/, softfloat_round_max /*RUP?*/,
+    softfloat_round_near_maxMag /*RMM*/
 };
 
 const uint32_t quiet_nan32 = 0x7fC00000;
@@ -56,7 +58,7 @@ uint32_t fget_flags() { return softfloat_exceptionFlags & 0x1f; }
 
 uint32_t fadd_s(uint32_t v1, uint32_t v2, uint8_t mode) {
     float32_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t r = f32_add(v1f, v2f);
     return r.v;
@@ -64,7 +66,7 @@ uint32_t fadd_s(uint32_t v1, uint32_t v2, uint8_t mode) {
 
 uint32_t fsub_s(uint32_t v1, uint32_t v2, uint8_t mode) {
     float32_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t r = f32_sub(v1f, v2f);
     return r.v;
@@ -72,7 +74,7 @@ uint32_t fsub_s(uint32_t v1, uint32_t v2, uint8_t mode) {
 
 uint32_t fmul_s(uint32_t v1, uint32_t v2, uint8_t mode) {
     float32_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t r = f32_mul(v1f, v2f);
     return r.v;
@@ -80,7 +82,7 @@ uint32_t fmul_s(uint32_t v1, uint32_t v2, uint8_t mode) {
 
 uint32_t fdiv_s(uint32_t v1, uint32_t v2, uint8_t mode) {
     float32_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t r = f32_div(v1f, v2f);
     return r.v;
@@ -88,7 +90,7 @@ uint32_t fdiv_s(uint32_t v1, uint32_t v2, uint8_t mode) {
 
 uint32_t fsqrt_s(uint32_t v1, uint8_t mode) {
     float32_t v1f{v1};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t r = f32_sqrt(v1f);
     return r.v;
@@ -126,22 +128,23 @@ uint32_t fcmp_s(uint32_t v1, uint32_t v2, uint32_t op) {
 }
 
 uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
+
     float32_t v1f{v1};
     softfloat_exceptionFlags = 0;
     float32_t r;
     switch(op) {
-    case 0: { // w->s, fp to int32
-        uint_fast32_t res = f32_to_i32(v1f, rmm_map[mode & 0x7], true);
+    case 0: { // FCVT__W__S
+        uint_fast32_t res = f32_to_i32(v1f, rmm_map.at(mode), true);
         return (uint32_t)res;
     }
-    case 1: { // wu->s
-        uint_fast32_t res = f32_to_ui32(v1f, rmm_map[mode & 0x7], true);
+    case 1: { // FCVT__WU__S
+        uint_fast32_t res = f32_to_ui32(v1f, rmm_map.at(mode), true);
         return (uint32_t)res;
     }
-    case 2: // s->w
-        r = i32_to_f32(v1);
+    case 2: // FCVT__S__W
+        r = i32_to_f32((int32_t)v1);
         return r.v;
-    case 3: // s->wu
+    case 3: // FCVT__S__WU
         r = ui32_to_f32(v1);
         return r.v;
     }
@@ -164,7 +167,7 @@ uint32_t fmadd_s(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mod
         v1 ^= F32_SIGN;
         break;
     }
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float32_t res = softfloat_mulAddF32(v1, v2, v3, 0);
     return res.v;
@@ -215,7 +218,7 @@ uint32_t fclass_s(uint32_t v1) {
 }
 
 uint32_t fconv_d2f(uint64_t v1, uint8_t mode) {
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     bool nan = (v1 & defaultNaNF64UI) == defaultNaNF64UI;
     if(nan) {
         return defaultNaNF32UI;
@@ -230,7 +233,7 @@ uint64_t fconv_f2d(uint32_t v1, uint8_t mode) {
     if(nan) {
         return defaultNaNF64UI;
     } else {
-        softfloat_roundingMode = rmm_map[mode & 0x7];
+        softfloat_roundingMode = rmm_map.at(mode);
         float64_t res = f32_to_f64(float32_t{v1});
         return res.v;
     }
@@ -240,7 +243,7 @@ uint64_t fadd_d(uint64_t v1, uint64_t v2, uint8_t mode) {
     bool nan = (v1 & defaultNaNF32UI) == quiet_nan32;
     bool snan = softfloat_isSigNaNF32UI(v1);
     float64_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t r = f64_add(v1f, v2f);
     return r.v;
@@ -248,7 +251,7 @@ uint64_t fadd_d(uint64_t v1, uint64_t v2, uint8_t mode) {
 
 uint64_t fsub_d(uint64_t v1, uint64_t v2, uint8_t mode) {
     float64_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t r = f64_sub(v1f, v2f);
     return r.v;
@@ -256,7 +259,7 @@ uint64_t fsub_d(uint64_t v1, uint64_t v2, uint8_t mode) {
 
 uint64_t fmul_d(uint64_t v1, uint64_t v2, uint8_t mode) {
     float64_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t r = f64_mul(v1f, v2f);
     return r.v;
@@ -264,7 +267,7 @@ uint64_t fmul_d(uint64_t v1, uint64_t v2, uint8_t mode) {
 
 uint64_t fdiv_d(uint64_t v1, uint64_t v2, uint8_t mode) {
     float64_t v1f{v1}, v2f{v2};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t r = f64_div(v1f, v2f);
     return r.v;
@@ -272,7 +275,7 @@ uint64_t fdiv_d(uint64_t v1, uint64_t v2, uint8_t mode) {
 
 uint64_t fsqrt_d(uint64_t v1, uint8_t mode) {
     float64_t v1f{v1};
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t r = f64_sqrt(v1f);
     return r.v;
@@ -315,11 +318,11 @@ uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
     float64_t r;
     switch(op) {
     case 0: { // l->d, fp to int32
-        int64_t res = f64_to_i64(v1f, rmm_map[mode & 0x7], true);
+        int64_t res = f64_to_i64(v1f, rmm_map.at(mode), true);
         return (uint64_t)res;
     }
     case 1: { // lu->s
-        uint64_t res = f64_to_ui64(v1f, rmm_map[mode & 0x7], true);
+        uint64_t res = f64_to_ui64(v1f, rmm_map.at(mode), true);
         return res;
     }
     case 2: // s->l
@@ -334,7 +337,7 @@ uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
 
 uint64_t fmadd_d(uint64_t v1, uint64_t v2, uint64_t v3, uint32_t op, uint8_t mode) {
     // op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
-    softfloat_roundingMode = rmm_map[mode & 0x7];
+    softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
     float64_t res = softfloat_mulAddF64(v1, v2, v3, op & 0x1);
     if(op > 1)
@@ -393,9 +396,9 @@ uint64_t fcvt_32_64(uint32_t v1, uint32_t op, uint8_t mode) {
     float64_t r;
     switch(op) {
     case 0: // l->s, fp to int32
-        return f32_to_i64(v1f, rmm_map[mode & 0x7], true);
+        return f32_to_i64(v1f, rmm_map.at(mode), true);
     case 1: // wu->s
-        return f32_to_ui64(v1f, rmm_map[mode & 0x7], true);
+        return f32_to_ui64(v1f, rmm_map.at(mode), true);
     case 2: // s->w
         r = i32_to_f64(v1);
         return r.v;
@@ -411,11 +414,11 @@ uint32_t fcvt_64_32(uint64_t v1, uint32_t op, uint8_t mode) {
     float32_t r;
     switch(op) {
     case 0: { // wu->s
-        int32_t r = f64_to_i32(float64_t{v1}, rmm_map[mode & 0x7], true);
+        int32_t r = f64_to_i32(float64_t{v1}, rmm_map.at(mode), true);
         return r;
     }
     case 1: { // wu->s
-        uint32_t r = f64_to_ui32(float64_t{v1}, rmm_map[mode & 0x7], true);
+        uint32_t r = f64_to_ui32(float64_t{v1}, rmm_map.at(mode), true);
         return r;
     }
     case 2: // l->s, fp to int32

From c376e34b2b4693147919106eafd8e61d2dfbd660 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Thu, 1 Aug 2024 11:02:10 +0200
Subject: [PATCH 058/100] applies clang format

---
 softfloat/source/8086-SSE/specialize.h        | 128 ++---
 softfloat/source/8086/specialize.h            | 122 ++---
 .../source/ARM-VFPv2-defaultNaN/specialize.h  | 168 +++---
 softfloat/source/ARM-VFPv2/specialize.h       | 120 ++---
 softfloat/source/RISCV/specialize.h           | 176 +++----
 softfloat/source/include/internals.h          | 330 ++++++------
 softfloat/source/include/primitiveTypes.h     |  65 ++-
 softfloat/source/include/primitives.h         | 384 +++++---------
 softfloat/source/include/softfloat.h          | 485 +++++++++---------
 softfloat/source/include/softfloat_types.h    |  31 +-
 10 files changed, 874 insertions(+), 1135 deletions(-)

diff --git a/softfloat/source/8086-SSE/specialize.h b/softfloat/source/8086-SSE/specialize.h
index 8ed2e75..428c1ed 100644
--- a/softfloat/source/8086-SSE/specialize.h
+++ b/softfloat/source/8086-SSE/specialize.h
@@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef specialize_h
 #define specialize_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitiveTypes.h"
 #include "softfloat.h"
+#include <stdbool.h>
+#include <stdint.h>
 
 /*----------------------------------------------------------------------------
 | Default value for 'softfloat_detectTininess'.
@@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #define ui32_fromPosOverflow 0xFFFFFFFF
 #define ui32_fromNegOverflow 0xFFFFFFFF
-#define ui32_fromNaN         0xFFFFFFFF
-#define i32_fromPosOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          (-0x7FFFFFFF - 1)
+#define ui32_fromNaN 0xFFFFFFFF
+#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN (-0x7FFFFFFF - 1)
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define i64_fromPosOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format
@@ -92,7 +92,7 @@ struct commonNaN {
 | 16-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
@@ -100,13 +100,13 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
@@ -114,15 +114,14 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
 
 /*----------------------------------------------------------------------------
 | Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
 | 16-bit brain floating-point (BF16) signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
+#define softfloat_isSigNaNBF16UI(uiA) ((((uiA)&0x7FC0) == 0x7F80) && ((uiA)&0x003F))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
@@ -130,13 +129,13 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_bf16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_bf16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr );
+uint_fast16_t softfloat_commonNaNToBF16UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -148,7 +147,7 @@ uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr );
 | 32-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
@@ -156,13 +155,13 @@ uint_fast16_t softfloat_commonNaNToBF16UI( const struct commonNaN *aPtr );
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
@@ -170,20 +169,20 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
 | 64-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
+    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
@@ -191,13 +190,13 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
@@ -205,14 +204,13 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
 *----------------------------------------------------------------------------*/
 #define defaultNaNExtF80UI64 0xFFFF
-#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 80-bit unsigned integer formed from concatenating
@@ -220,7 +218,8 @@ uint_fast64_t
 | floating-point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
+    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
@@ -236,16 +235,14 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and returns the bit pattern of this value as an unsigned
 | integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -256,19 +253,13 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
 | result.  If either original floating-point value is a signaling NaN, the
 | invalid exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
-#define defaultNaNF128UI0  UINT64_C( 0 )
+#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
+#define defaultNaNF128UI0 UINT64_C(0)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 128-bit unsigned integer formed from concatenating
@@ -276,7 +267,8 @@ struct uint128
 | point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
+    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
 
 /*----------------------------------------------------------------------------
 | Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
@@ -285,15 +277,13 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -304,13 +294,7 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
 | If either original floating-point value is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
 
 #else
 
@@ -325,18 +309,14 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and stores this NaN at the location pointed to by
 | 'zSPtr'.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 80-bit extended floating-point values
@@ -344,12 +324,7 @@ void
 | at the location pointed to by 'zSPtr'.  If either original floating-point
 | value is a signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- );
+void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
@@ -357,7 +332,7 @@ void
 #define defaultNaNF128UI96 0xFFFF8000
 #define defaultNaNF128UI64 0
 #define defaultNaNF128UI32 0
-#define defaultNaNF128UI0  0
+#define defaultNaNF128UI0 0
 
 /*----------------------------------------------------------------------------
 | Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
@@ -367,8 +342,7 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -376,8 +350,7 @@ void
 | 'zWPtr' points to an array of four 32-bit elements that concatenate in the
 | platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 128-bit floating-point values pointed to by
@@ -387,11 +360,8 @@ void
 | and 'zWPtr' points to an array of four 32-bit elements that concatenate in
 | the platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/8086/specialize.h b/softfloat/source/8086/specialize.h
index a9166e1..ad836e3 100644
--- a/softfloat/source/8086/specialize.h
+++ b/softfloat/source/8086/specialize.h
@@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef specialize_h
 #define specialize_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitiveTypes.h"
 #include "softfloat.h"
+#include <stdbool.h>
+#include <stdint.h>
 
 /*----------------------------------------------------------------------------
 | Default value for 'softfloat_detectTininess'.
@@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #define ui32_fromPosOverflow 0xFFFFFFFF
 #define ui32_fromNegOverflow 0xFFFFFFFF
-#define ui32_fromNaN         0xFFFFFFFF
-#define i32_fromPosOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          (-0x7FFFFFFF - 1)
+#define ui32_fromNaN 0xFFFFFFFF
+#define i32_fromPosOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN (-0x7FFFFFFF - 1)
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNegOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define i64_fromPosOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
+#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define ui64_fromNegOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define i64_fromPosOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNaN (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format
@@ -92,7 +92,7 @@ struct commonNaN {
 | 16-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
@@ -100,13 +100,13 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
@@ -114,8 +114,7 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -127,7 +126,7 @@ uint_fast16_t
 | 32-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
@@ -135,13 +134,13 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
@@ -149,20 +148,20 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C( 0xFFF8000000000000 )
+#define defaultNaNF64UI UINT64_C(0xFFF8000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
 | 64-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
+    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
@@ -170,13 +169,13 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
@@ -184,14 +183,13 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
 *----------------------------------------------------------------------------*/
 #define defaultNaNExtF80UI64 0xFFFF
-#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 80-bit unsigned integer formed from concatenating
@@ -199,7 +197,8 @@ uint_fast64_t
 | floating-point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
+    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
@@ -215,16 +214,14 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and returns the bit pattern of this value as an unsigned
 | integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -235,19 +232,13 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
 | result.  If either original floating-point value is a signaling NaN, the
 | invalid exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C( 0xFFFF800000000000 )
-#define defaultNaNF128UI0  UINT64_C( 0 )
+#define defaultNaNF128UI64 UINT64_C(0xFFFF800000000000)
+#define defaultNaNF128UI0 UINT64_C(0)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 128-bit unsigned integer formed from concatenating
@@ -255,7 +246,8 @@ struct uint128
 | point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
+    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
 
 /*----------------------------------------------------------------------------
 | Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
@@ -264,15 +256,13 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -283,13 +273,7 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
 | If either original floating-point value is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
 
 #else
 
@@ -304,18 +288,14 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and stores this NaN at the location pointed to by
 | 'zSPtr'.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 80-bit extended floating-point values
@@ -323,12 +303,7 @@ void
 | at the location pointed to by 'zSPtr'.  If either original floating-point
 | value is a signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- );
+void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
@@ -336,7 +311,7 @@ void
 #define defaultNaNF128UI96 0xFFFF8000
 #define defaultNaNF128UI64 0
 #define defaultNaNF128UI32 0
-#define defaultNaNF128UI0  0
+#define defaultNaNF128UI0 0
 
 /*----------------------------------------------------------------------------
 | Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
@@ -346,8 +321,7 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -355,8 +329,7 @@ void
 | 'zWPtr' points to an array of four 32-bit elements that concatenate in the
 | platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 128-bit floating-point values pointed to by
@@ -366,11 +339,8 @@ void
 | and 'zWPtr' points to an array of four 32-bit elements that concatenate in
 | the platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h b/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
index e4ea15d..7143282 100644
--- a/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
+++ b/softfloat/source/ARM-VFPv2-defaultNaN/specialize.h
@@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef specialize_h
 #define specialize_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitiveTypes.h"
 #include "softfloat.h"
+#include <stdbool.h>
+#include <stdint.h>
 
 /*----------------------------------------------------------------------------
 | Default value for 'softfloat_detectTininess'.
@@ -53,27 +53,29 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #define ui32_fromPosOverflow 0xFFFFFFFF
 #define ui32_fromNegOverflow 0
-#define ui32_fromNaN         0
-#define i32_fromPosOverflow  0x7FFFFFFF
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          0
+#define ui32_fromNaN 0
+#define i32_fromPosOverflow 0x7FFFFFFF
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN 0
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
 #define ui64_fromNegOverflow 0
-#define ui64_fromNaN         0
-#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          0
+#define ui64_fromNaN 0
+#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
+#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNaN 0
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format
 | to another.
 *----------------------------------------------------------------------------*/
-struct commonNaN { char _unused; };
+struct commonNaN {
+    char _unused;
+};
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 16-bit floating-point NaN.
@@ -85,7 +87,7 @@ struct commonNaN { char _unused; };
 | 16-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
@@ -93,13 +95,15 @@ struct commonNaN { char _unused; };
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f16UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&0x0200))                                                                                                                    \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
+#define softfloat_commonNaNToF16UI(aPtr) ((uint_fast16_t)defaultNaNF16UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
@@ -107,8 +111,7 @@ struct commonNaN { char _unused; };
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -120,7 +123,7 @@ uint_fast16_t
 | 32-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
@@ -128,13 +131,15 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f32UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&0x00400000))                                                                                                                \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
+#define softfloat_commonNaNToF32UI(aPtr) ((uint_fast32_t)defaultNaNF32UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
@@ -142,20 +147,20 @@ uint_fast16_t
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
 | 64-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
+    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
@@ -163,13 +168,15 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f64UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&UINT64_C(0x0008000000000000)))                                                                                              \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
+#define softfloat_commonNaNToF64UI(aPtr) ((uint_fast64_t)defaultNaNF64UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
@@ -177,14 +184,13 @@ uint_fast32_t
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
 *----------------------------------------------------------------------------*/
 #define defaultNaNExtF80UI64 0x7FFF
-#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 80-bit unsigned integer formed from concatenating
@@ -192,7 +198,8 @@ uint_fast64_t
 | floating-point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
+    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
@@ -208,24 +215,25 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                   \
+    if(!((uiA0)&UINT64_C(0x4000000000000000)))                                                                                             \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and returns the bit pattern of this value as an unsigned
 | integer.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
+#if defined INLINE && !defined softfloat_commonNaNToExtF80UI
 INLINE
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr) {
     struct uint128 uiZ;
     uiZ.v64 = defaultNaNExtF80UI64;
-    uiZ.v0  = defaultNaNExtF80UI0;
+    uiZ.v0 = defaultNaNExtF80UI0;
     return uiZ;
 }
 #else
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -237,19 +245,13 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
 | result.  If either original floating-point value is a signaling NaN, the
 | invalid exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
-#define defaultNaNF128UI0  UINT64_C( 0 )
+#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
+#define defaultNaNF128UI0 UINT64_C(0)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 128-bit unsigned integer formed from concatenating
@@ -257,7 +259,8 @@ struct uint128
 | point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
+    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
 
 /*----------------------------------------------------------------------------
 | Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
@@ -266,23 +269,24 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                     \
+    if(!((uiA64)&UINT64_C(0x0000800000000000)))                                                                                            \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToF128UI
+#if defined INLINE && !defined softfloat_commonNaNToF128UI
 INLINE
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN* aPtr) {
     struct uint128 uiZ;
     uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
+    uiZ.v0 = defaultNaNF128UI0;
     return uiZ;
 }
 #else
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -294,13 +298,7 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
 | If either original floating-point value is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
 
 #else
 
@@ -315,26 +313,23 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80MToCommonNaN(aSPtr, zPtr)                                                                                          \
+    if(!((aSPtr)->signif & UINT64_C(0x4000000000000000)))                                                                                  \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and stores this NaN at the location pointed to by
 | 'zSPtr'.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
+#if defined INLINE && !defined softfloat_commonNaNToExtF80M
 INLINE
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr) {
     zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif  = defaultNaNExtF80UI0;
+    zSPtr->signif = defaultNaNExtF80UI0;
 }
 #else
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -343,12 +338,7 @@ void
 | at the location pointed to by 'zSPtr'.  If either original floating-point
 | value is a signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- );
+void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
@@ -356,7 +346,7 @@ void
 #define defaultNaNF128UI96 0x7FFF8000
 #define defaultNaNF128UI64 0
 #define defaultNaNF128UI32 0
-#define defaultNaNF128UI0  0
+#define defaultNaNF128UI0 0
 
 /*----------------------------------------------------------------------------
 | Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
@@ -366,7 +356,9 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128MToCommonNaN(aWPtr, zPtr)                                                                                            \
+    if(!((aWPtr)[indexWordHi(4)] & UINT64_C(0x0000800000000000)))                                                                          \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -374,19 +366,16 @@ void
 | 'zWPtr' points to an array of four 32-bit elements that concatenate in the
 | platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToF128M
+#if defined INLINE && !defined softfloat_commonNaNToF128M
 INLINE
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
-    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
-    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
-    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr) {
+    zWPtr[indexWord(4, 3)] = defaultNaNF128UI96;
+    zWPtr[indexWord(4, 2)] = defaultNaNF128UI64;
+    zWPtr[indexWord(4, 1)] = defaultNaNF128UI32;
+    zWPtr[indexWord(4, 0)] = defaultNaNF128UI0;
 }
 #else
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -397,11 +386,8 @@ void
 | and 'zWPtr' points to an array of four 32-bit elements that concatenate in
 | the platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/ARM-VFPv2/specialize.h b/softfloat/source/ARM-VFPv2/specialize.h
index 10b0b35..a75c585 100644
--- a/softfloat/source/ARM-VFPv2/specialize.h
+++ b/softfloat/source/ARM-VFPv2/specialize.h
@@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef specialize_h
 #define specialize_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitiveTypes.h"
 #include "softfloat.h"
+#include <stdbool.h>
+#include <stdint.h>
 
 /*----------------------------------------------------------------------------
 | Default value for 'softfloat_detectTininess'.
@@ -53,21 +53,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #define ui32_fromPosOverflow 0xFFFFFFFF
 #define ui32_fromNegOverflow 0
-#define ui32_fromNaN         0
-#define i32_fromPosOverflow  0x7FFFFFFF
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          0
+#define ui32_fromNaN 0
+#define i32_fromPosOverflow 0x7FFFFFFF
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN 0
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
 #define ui64_fromNegOverflow 0
-#define ui64_fromNaN         0
-#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          0
+#define ui64_fromNaN 0
+#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
+#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNaN 0
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format
@@ -92,7 +92,7 @@ struct commonNaN {
 | 16-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
@@ -100,13 +100,13 @@ struct commonNaN {
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f16UIToCommonNaN( uint_fast16_t uiA, struct commonNaN *zPtr );
+void softfloat_f16UIToCommonNaN(uint_fast16_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
+uint_fast16_t softfloat_commonNaNToF16UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
@@ -114,8 +114,7 @@ uint_fast16_t softfloat_commonNaNToF16UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -127,7 +126,7 @@ uint_fast16_t
 | 32-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
@@ -135,13 +134,13 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f32UIToCommonNaN( uint_fast32_t uiA, struct commonNaN *zPtr );
+void softfloat_f32UIToCommonNaN(uint_fast32_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
+uint_fast32_t softfloat_commonNaNToF32UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
@@ -149,20 +148,20 @@ uint_fast32_t softfloat_commonNaNToF32UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
 | 64-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
+    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
@@ -170,13 +169,13 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void softfloat_f64UIToCommonNaN( uint_fast64_t uiA, struct commonNaN *zPtr );
+void softfloat_f64UIToCommonNaN(uint_fast64_t uiA, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
+uint_fast64_t softfloat_commonNaNToF64UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
@@ -184,14 +183,13 @@ uint_fast64_t softfloat_commonNaNToF64UI( const struct commonNaN *aPtr );
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
 *----------------------------------------------------------------------------*/
 #define defaultNaNExtF80UI64 0x7FFF
-#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 80-bit unsigned integer formed from concatenating
@@ -199,7 +197,8 @@ uint_fast64_t
 | floating-point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
+    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
@@ -215,16 +214,14 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80UIToCommonNaN(
-     uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_extF80UIToCommonNaN(uint_fast16_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and returns the bit pattern of this value as an unsigned
 | integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -235,19 +232,13 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
 | result.  If either original floating-point value is a signaling NaN, the
 | invalid exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
-#define defaultNaNF128UI0  UINT64_C( 0 )
+#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
+#define defaultNaNF128UI0 UINT64_C(0)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 128-bit unsigned integer formed from concatenating
@@ -255,7 +246,8 @@ struct uint128
 | point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
+    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
 
 /*----------------------------------------------------------------------------
 | Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
@@ -264,15 +256,13 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128UIToCommonNaN(
-     uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN *zPtr );
+void softfloat_f128UIToCommonNaN(uint_fast64_t uiA64, uint_fast64_t uiA0, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
 
 /*----------------------------------------------------------------------------
 | Interpreting the unsigned integer formed from concatenating 'uiA64' and
@@ -283,13 +273,7 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
 | If either original floating-point value is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
 
 #else
 
@@ -304,18 +288,14 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_extF80MToCommonNaN(
-     const struct extFloat80M *aSPtr, struct commonNaN *zPtr );
+void softfloat_extF80MToCommonNaN(const struct extFloat80M* aSPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and stores this NaN at the location pointed to by
 | 'zSPtr'.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 80-bit extended floating-point values
@@ -323,12 +303,7 @@ void
 | at the location pointed to by 'zSPtr'.  If either original floating-point
 | value is a signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- );
+void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
@@ -336,7 +311,7 @@ void
 #define defaultNaNF128UI96 0x7FFF8000
 #define defaultNaNF128UI64 0
 #define defaultNaNF128UI32 0
-#define defaultNaNF128UI0  0
+#define defaultNaNF128UI0 0
 
 /*----------------------------------------------------------------------------
 | Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
@@ -346,8 +321,7 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_f128MToCommonNaN( const uint32_t *aWPtr, struct commonNaN *zPtr );
+void softfloat_f128MToCommonNaN(const uint32_t* aWPtr, struct commonNaN* zPtr);
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -355,8 +329,7 @@ void
 | 'zWPtr' points to an array of four 32-bit elements that concatenate in the
 | platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
 
 /*----------------------------------------------------------------------------
 | Assuming at least one of the two 128-bit floating-point values pointed to by
@@ -366,11 +339,8 @@ void
 | and 'zWPtr' points to an array of four 32-bit elements that concatenate in
 | the platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/RISCV/specialize.h b/softfloat/source/RISCV/specialize.h
index cb95900..fe19494 100644
--- a/softfloat/source/RISCV/specialize.h
+++ b/softfloat/source/RISCV/specialize.h
@@ -37,10 +37,10 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef specialize_h
 #define specialize_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitiveTypes.h"
 #include "softfloat.h"
+#include <stdbool.h>
+#include <stdint.h>
 
 /*----------------------------------------------------------------------------
 | Default value for 'softfloat_detectTininess'.
@@ -53,27 +53,29 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #define ui32_fromPosOverflow 0xFFFFFFFF
 #define ui32_fromNegOverflow 0
-#define ui32_fromNaN         0xFFFFFFFF
-#define i32_fromPosOverflow  0x7FFFFFFF
-#define i32_fromNegOverflow  (-0x7FFFFFFF - 1)
-#define i32_fromNaN          0x7FFFFFFF
+#define ui32_fromNaN 0xFFFFFFFF
+#define i32_fromPosOverflow 0x7FFFFFFF
+#define i32_fromNegOverflow (-0x7FFFFFFF - 1)
+#define i32_fromNaN 0x7FFFFFFF
 
 /*----------------------------------------------------------------------------
 | The values to return on conversions to 64-bit integer formats that raise an
 | invalid exception.
 *----------------------------------------------------------------------------*/
-#define ui64_fromPosOverflow UINT64_C( 0xFFFFFFFFFFFFFFFF )
+#define ui64_fromPosOverflow UINT64_C(0xFFFFFFFFFFFFFFFF)
 #define ui64_fromNegOverflow 0
-#define ui64_fromNaN         UINT64_C( 0xFFFFFFFFFFFFFFFF )
-#define i64_fromPosOverflow  INT64_C( 0x7FFFFFFFFFFFFFFF )
-#define i64_fromNegOverflow  (-INT64_C( 0x7FFFFFFFFFFFFFFF ) - 1)
-#define i64_fromNaN          INT64_C( 0x7FFFFFFFFFFFFFFF )
+#define ui64_fromNaN UINT64_C(0xFFFFFFFFFFFFFFFF)
+#define i64_fromPosOverflow INT64_C(0x7FFFFFFFFFFFFFFF)
+#define i64_fromNegOverflow (-INT64_C(0x7FFFFFFFFFFFFFFF) - 1)
+#define i64_fromNaN INT64_C(0x7FFFFFFFFFFFFFFF)
 
 /*----------------------------------------------------------------------------
 | "Common NaN" structure, used to transfer NaN representations from one format
 | to another.
 *----------------------------------------------------------------------------*/
-struct commonNaN { char _unused; };
+struct commonNaN {
+    char _unused;
+};
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 16-bit floating-point NaN.
@@ -85,14 +87,14 @@ struct commonNaN { char _unused; };
 | 16-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF16UI( uiA ) ((((uiA) & 0x7E00) == 0x7C00) && ((uiA) & 0x01FF))
+#define softfloat_isSigNaNF16UI(uiA) ((((uiA)&0x7E00) == 0x7C00) && ((uiA)&0x01FF))
 
 /*----------------------------------------------------------------------------
 | Returns true when 16-bit unsigned integer 'uiA' has the bit pattern of a
 | 16-bit brain floating-point (BF16) signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNBF16UI( uiA ) ((((uiA) & 0x7FC0) == 0x7F80) && ((uiA) & 0x003F))
+#define softfloat_isSigNaNBF16UI(uiA) ((((uiA)&0x7FC0) == 0x7F80) && ((uiA)&0x003F))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit floating-point NaN, converts
@@ -100,7 +102,9 @@ struct commonNaN { char _unused; };
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0200) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f16UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&0x0200))                                                                                                                    \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 16-bit BF16 floating-point NaN, converts
@@ -108,13 +112,15 @@ struct commonNaN { char _unused; };
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_bf16UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x0040) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_bf16UIToCommonNaN(uiA, zPtr)                                                                                             \
+    if(!((uiA)&0x0040))                                                                                                                    \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF16UI( aPtr ) ((uint_fast16_t) defaultNaNF16UI)
+#define softfloat_commonNaNToF16UI(aPtr) ((uint_fast16_t)defaultNaNF16UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 16-bit floating-
@@ -122,8 +128,7 @@ struct commonNaN { char _unused; };
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast16_t
- softfloat_propagateNaNF16UI( uint_fast16_t uiA, uint_fast16_t uiB );
+uint_fast16_t softfloat_propagateNaNF16UI(uint_fast16_t uiA, uint_fast16_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 16-bit BF16 floating-point NaN.
@@ -134,7 +139,7 @@ uint_fast16_t
 | Converts the common NaN pointed to by 'aPtr' into a 16-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToBF16UI( aPtr ) ((uint_fast16_t) defaultNaNBF16UI)
+#define softfloat_commonNaNToBF16UI(aPtr) ((uint_fast16_t)defaultNaNBF16UI)
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 32-bit floating-point NaN.
@@ -146,7 +151,7 @@ uint_fast16_t
 | 32-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF32UI( uiA ) ((((uiA) & 0x7FC00000) == 0x7F800000) && ((uiA) & 0x003FFFFF))
+#define softfloat_isSigNaNF32UI(uiA) ((((uiA)&0x7FC00000) == 0x7F800000) && ((uiA)&0x003FFFFF))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 32-bit floating-point NaN, converts
@@ -154,13 +159,15 @@ uint_fast16_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f32UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & 0x00400000) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f32UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&0x00400000))                                                                                                                \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 32-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF32UI( aPtr ) ((uint_fast32_t) defaultNaNF32UI)
+#define softfloat_commonNaNToF32UI(aPtr) ((uint_fast32_t)defaultNaNF32UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 32-bit floating-
@@ -168,20 +175,20 @@ uint_fast16_t
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast32_t
- softfloat_propagateNaNF32UI( uint_fast32_t uiA, uint_fast32_t uiB );
+uint_fast32_t softfloat_propagateNaNF32UI(uint_fast32_t uiA, uint_fast32_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 64-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF64UI UINT64_C( 0x7FF8000000000000 )
+#define defaultNaNF64UI UINT64_C(0x7FF8000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when 64-bit unsigned integer 'uiA' has the bit pattern of a
 | 64-bit floating-point signaling NaN.
 | Note:  This macro evaluates its argument more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF64UI( uiA ) ((((uiA) & UINT64_C( 0x7FF8000000000000 )) == UINT64_C( 0x7FF0000000000000 )) && ((uiA) & UINT64_C( 0x0007FFFFFFFFFFFF )))
+#define softfloat_isSigNaNF64UI(uiA)                                                                                                       \
+    ((((uiA)&UINT64_C(0x7FF8000000000000)) == UINT64_C(0x7FF0000000000000)) && ((uiA)&UINT64_C(0x0007FFFFFFFFFFFF)))
 
 /*----------------------------------------------------------------------------
 | Assuming 'uiA' has the bit pattern of a 64-bit floating-point NaN, converts
@@ -189,13 +196,15 @@ uint_fast32_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f64UIToCommonNaN( uiA, zPtr ) if ( ! ((uiA) & UINT64_C( 0x0008000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f64UIToCommonNaN(uiA, zPtr)                                                                                              \
+    if(!((uiA)&UINT64_C(0x0008000000000000)))                                                                                              \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 64-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#define softfloat_commonNaNToF64UI( aPtr ) ((uint_fast64_t) defaultNaNF64UI)
+#define softfloat_commonNaNToF64UI(aPtr) ((uint_fast64_t)defaultNaNF64UI)
 
 /*----------------------------------------------------------------------------
 | Interpreting 'uiA' and 'uiB' as the bit patterns of two 64-bit floating-
@@ -203,14 +212,13 @@ uint_fast32_t
 | the combined NaN result.  If either 'uiA' or 'uiB' has the pattern of a
 | signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-uint_fast64_t
- softfloat_propagateNaNF64UI( uint_fast64_t uiA, uint_fast64_t uiB );
+uint_fast64_t softfloat_propagateNaNF64UI(uint_fast64_t uiA, uint_fast64_t uiB);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 80-bit extended floating-point NaN.
 *----------------------------------------------------------------------------*/
 #define defaultNaNExtF80UI64 0x7FFF
-#define defaultNaNExtF80UI0  UINT64_C( 0xC000000000000000 )
+#define defaultNaNExtF80UI0 UINT64_C(0xC000000000000000)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 80-bit unsigned integer formed from concatenating
@@ -218,7 +226,8 @@ uint_fast64_t
 | floating-point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNExtF80UI( uiA64, uiA0 ) ((((uiA64) & 0x7FFF) == 0x7FFF) && ! ((uiA0) & UINT64_C( 0x4000000000000000 )) && ((uiA0) & UINT64_C( 0x3FFFFFFFFFFFFFFF )))
+#define softfloat_isSigNaNExtF80UI(uiA64, uiA0)                                                                                            \
+    ((((uiA64)&0x7FFF) == 0x7FFF) && !((uiA0)&UINT64_C(0x4000000000000000)) && ((uiA0)&UINT64_C(0x3FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
@@ -234,24 +243,25 @@ uint_fast64_t
 | location pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA0) & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                   \
+    if(!((uiA0)&UINT64_C(0x4000000000000000)))                                                                                             \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and returns the bit pattern of this value as an unsigned
 | integer.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToExtF80UI
+#if defined INLINE && !defined softfloat_commonNaNToExtF80UI
 INLINE
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr )
-{
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr) {
     struct uint128 uiZ;
     uiZ.v64 = defaultNaNExtF80UI64;
-    uiZ.v0  = defaultNaNExtF80UI0;
+    uiZ.v0 = defaultNaNExtF80UI0;
     return uiZ;
 }
 #else
-struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
+struct uint128 softfloat_commonNaNToExtF80UI(const struct commonNaN* aPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -263,19 +273,13 @@ struct uint128 softfloat_commonNaNToExtF80UI( const struct commonNaN *aPtr );
 | result.  If either original floating-point value is a signaling NaN, the
 | invalid exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNExtF80UI(
-     uint_fast16_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast16_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNExtF80UI(uint_fast16_t uiA64, uint_fast64_t uiA0, uint_fast16_t uiB64, uint_fast64_t uiB0);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
 *----------------------------------------------------------------------------*/
-#define defaultNaNF128UI64 UINT64_C( 0x7FFF800000000000 )
-#define defaultNaNF128UI0  UINT64_C( 0 )
+#define defaultNaNF128UI64 UINT64_C(0x7FFF800000000000)
+#define defaultNaNF128UI0 UINT64_C(0)
 
 /*----------------------------------------------------------------------------
 | Returns true when the 128-bit unsigned integer formed from concatenating
@@ -283,7 +287,8 @@ struct uint128
 | point signaling NaN.
 | Note:  This macro evaluates its arguments more than once.
 *----------------------------------------------------------------------------*/
-#define softfloat_isSigNaNF128UI( uiA64, uiA0 ) ((((uiA64) & UINT64_C( 0x7FFF800000000000 )) == UINT64_C( 0x7FFF000000000000 )) && ((uiA0) || ((uiA64) & UINT64_C( 0x00007FFFFFFFFFFF ))))
+#define softfloat_isSigNaNF128UI(uiA64, uiA0)                                                                                              \
+    ((((uiA64)&UINT64_C(0x7FFF800000000000)) == UINT64_C(0x7FFF000000000000)) && ((uiA0) || ((uiA64)&UINT64_C(0x00007FFFFFFFFFFF))))
 
 /*----------------------------------------------------------------------------
 | Assuming the unsigned integer formed from concatenating 'uiA64' and 'uiA0'
@@ -292,23 +297,24 @@ struct uint128
 | pointed to by 'zPtr'.  If the NaN is a signaling NaN, the invalid exception
 | is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128UIToCommonNaN( uiA64, uiA0, zPtr ) if ( ! ((uiA64) & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128UIToCommonNaN(uiA64, uiA0, zPtr)                                                                                     \
+    if(!((uiA64)&UINT64_C(0x0000800000000000)))                                                                                            \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
 | NaN, and returns the bit pattern of this value as an unsigned integer.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToF128UI
+#if defined INLINE && !defined softfloat_commonNaNToF128UI
 INLINE
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN *aPtr )
-{
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN* aPtr) {
     struct uint128 uiZ;
     uiZ.v64 = defaultNaNF128UI64;
-    uiZ.v0  = defaultNaNF128UI0;
+    uiZ.v0 = defaultNaNF128UI0;
     return uiZ;
 }
 #else
-struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
+struct uint128 softfloat_commonNaNToF128UI(const struct commonNaN*);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -320,13 +326,7 @@ struct uint128 softfloat_commonNaNToF128UI( const struct commonNaN * );
 | If either original floating-point value is a signaling NaN, the invalid
 | exception is raised.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_propagateNaNF128UI(
-     uint_fast64_t uiA64,
-     uint_fast64_t uiA0,
-     uint_fast64_t uiB64,
-     uint_fast64_t uiB0
- );
+struct uint128 softfloat_propagateNaNF128UI(uint_fast64_t uiA64, uint_fast64_t uiA0, uint_fast64_t uiB64, uint_fast64_t uiB0);
 
 #else
 
@@ -341,26 +341,23 @@ struct uint128
 | common NaN at the location pointed to by 'zPtr'.  If the NaN is a signaling
 | NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-#define softfloat_extF80MToCommonNaN( aSPtr, zPtr ) if ( ! ((aSPtr)->signif & UINT64_C( 0x4000000000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_extF80MToCommonNaN(aSPtr, zPtr)                                                                                          \
+    if(!((aSPtr)->signif & UINT64_C(0x4000000000000000)))                                                                                  \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into an 80-bit extended
 | floating-point NaN, and stores this NaN at the location pointed to by
 | 'zSPtr'.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToExtF80M
+#if defined INLINE && !defined softfloat_commonNaNToExtF80M
 INLINE
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr )
-{
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr) {
     zSPtr->signExp = defaultNaNExtF80UI64;
-    zSPtr->signif  = defaultNaNExtF80UI0;
+    zSPtr->signif = defaultNaNExtF80UI0;
 }
 #else
-void
- softfloat_commonNaNToExtF80M(
-     const struct commonNaN *aPtr, struct extFloat80M *zSPtr );
+void softfloat_commonNaNToExtF80M(const struct commonNaN* aPtr, struct extFloat80M* zSPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -369,12 +366,7 @@ void
 | at the location pointed to by 'zSPtr'.  If either original floating-point
 | value is a signaling NaN, the invalid exception is raised.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNExtF80M(
-     const struct extFloat80M *aSPtr,
-     const struct extFloat80M *bSPtr,
-     struct extFloat80M *zSPtr
- );
+void softfloat_propagateNaNExtF80M(const struct extFloat80M* aSPtr, const struct extFloat80M* bSPtr, struct extFloat80M* zSPtr);
 
 /*----------------------------------------------------------------------------
 | The bit pattern for a default generated 128-bit floating-point NaN.
@@ -382,7 +374,7 @@ void
 #define defaultNaNF128UI96 0x7FFF8000
 #define defaultNaNF128UI64 0
 #define defaultNaNF128UI32 0
-#define defaultNaNF128UI0  0
+#define defaultNaNF128UI0 0
 
 /*----------------------------------------------------------------------------
 | Assuming the 128-bit floating-point value pointed to by 'aWPtr' is a NaN,
@@ -392,7 +384,9 @@ void
 | four 32-bit elements that concatenate in the platform's normal endian order
 | to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#define softfloat_f128MToCommonNaN( aWPtr, zPtr ) if ( ! ((aWPtr)[indexWordHi( 4 )] & UINT64_C( 0x0000800000000000 )) ) softfloat_raiseFlags( softfloat_flag_invalid )
+#define softfloat_f128MToCommonNaN(aWPtr, zPtr)                                                                                            \
+    if(!((aWPtr)[indexWordHi(4)] & UINT64_C(0x0000800000000000)))                                                                          \
+    softfloat_raiseFlags(softfloat_flag_invalid)
 
 /*----------------------------------------------------------------------------
 | Converts the common NaN pointed to by 'aPtr' into a 128-bit floating-point
@@ -400,19 +394,16 @@ void
 | 'zWPtr' points to an array of four 32-bit elements that concatenate in the
 | platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-#if defined INLINE && ! defined softfloat_commonNaNToF128M
+#if defined INLINE && !defined softfloat_commonNaNToF128M
 INLINE
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr )
-{
-    zWPtr[indexWord( 4, 3 )] = defaultNaNF128UI96;
-    zWPtr[indexWord( 4, 2 )] = defaultNaNF128UI64;
-    zWPtr[indexWord( 4, 1 )] = defaultNaNF128UI32;
-    zWPtr[indexWord( 4, 0 )] = defaultNaNF128UI0;
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr) {
+    zWPtr[indexWord(4, 3)] = defaultNaNF128UI96;
+    zWPtr[indexWord(4, 2)] = defaultNaNF128UI64;
+    zWPtr[indexWord(4, 1)] = defaultNaNF128UI32;
+    zWPtr[indexWord(4, 0)] = defaultNaNF128UI0;
 }
 #else
-void
- softfloat_commonNaNToF128M( const struct commonNaN *aPtr, uint32_t *zWPtr );
+void softfloat_commonNaNToF128M(const struct commonNaN* aPtr, uint32_t* zWPtr);
 #endif
 
 /*----------------------------------------------------------------------------
@@ -423,11 +414,8 @@ void
 | and 'zWPtr' points to an array of four 32-bit elements that concatenate in
 | the platform's normal endian order to form a 128-bit floating-point value.
 *----------------------------------------------------------------------------*/
-void
- softfloat_propagateNaNF128M(
-     const uint32_t *aWPtr, const uint32_t *bWPtr, uint32_t *zWPtr );
+void softfloat_propagateNaNF128M(const uint32_t* aWPtr, const uint32_t* bWPtr, uint32_t* zWPtr);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/include/internals.h b/softfloat/source/include/internals.h
index 5e6d4bd..be7c875 100644
--- a/softfloat/source/include/internals.h
+++ b/softfloat/source/include/internals.h
@@ -37,255 +37,221 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef internals_h
 #define internals_h 1
 
-#include <stdbool.h>
-#include <stdint.h>
 #include "primitives.h"
 #include "softfloat_types.h"
+#include <stdbool.h>
+#include <stdint.h>
 
-union ui16_f16 { uint16_t ui; float16_t f; };
-union ui16_bf16 { uint16_t ui; bfloat16_t f; };
-union ui32_f32 { uint32_t ui; float32_t f; };
-union ui64_f64 { uint64_t ui; float64_t f; };
-
-#ifdef SOFTFLOAT_FAST_INT64
-union extF80M_extF80 { struct extFloat80M fM; extFloat80_t f; };
-union ui128_f128 { struct uint128 ui; float128_t f; };
-#endif
-
-enum {
-    softfloat_mulAdd_subC    = 1,
-    softfloat_mulAdd_subProd = 2
+union ui16_f16 {
+    uint16_t ui;
+    float16_t f;
+};
+union ui16_bf16 {
+    uint16_t ui;
+    bfloat16_t f;
+};
+union ui32_f32 {
+    uint32_t ui;
+    float32_t f;
+};
+union ui64_f64 {
+    uint64_t ui;
+    float64_t f;
 };
 
-/*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-uint_fast32_t softfloat_roundToUI32( bool, uint_fast64_t, uint_fast8_t, bool );
-
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast64_t
- softfloat_roundToUI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
-#else
-uint_fast64_t softfloat_roundMToUI64( bool, uint32_t *, uint_fast8_t, bool );
+union extF80M_extF80 {
+    struct extFloat80M fM;
+    extFloat80_t f;
+};
+union ui128_f128 {
+    struct uint128 ui;
+    float128_t f;
+};
 #endif
 
-int_fast32_t softfloat_roundToI32( bool, uint_fast64_t, uint_fast8_t, bool );
+enum { softfloat_mulAdd_subC = 1, softfloat_mulAdd_subProd = 2 };
+
+/*----------------------------------------------------------------------------
+ *----------------------------------------------------------------------------*/
+uint_fast32_t softfloat_roundToUI32(bool, uint_fast64_t, uint_fast8_t, bool);
 
 #ifdef SOFTFLOAT_FAST_INT64
-int_fast64_t
- softfloat_roundToI64(
-     bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool );
+uint_fast64_t softfloat_roundToUI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
 #else
-int_fast64_t softfloat_roundMToI64( bool, uint32_t *, uint_fast8_t, bool );
+uint_fast64_t softfloat_roundMToUI64(bool, uint32_t*, uint_fast8_t, bool);
+#endif
+
+int_fast32_t softfloat_roundToI32(bool, uint_fast64_t, uint_fast8_t, bool);
+
+#ifdef SOFTFLOAT_FAST_INT64
+int_fast64_t softfloat_roundToI64(bool, uint_fast64_t, uint_fast64_t, uint_fast8_t, bool);
+#else
+int_fast64_t softfloat_roundMToI64(bool, uint32_t*, uint_fast8_t, bool);
 #endif
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signF16UI( a ) ((bool) ((uint16_t) (a)>>15))
-#define expF16UI( a ) ((int_fast8_t) ((a)>>10) & 0x1F)
-#define fracF16UI( a ) ((a) & 0x03FF)
-#define packToF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<10) + (sig))
+ *----------------------------------------------------------------------------*/
+#define signF16UI(a) ((bool)((uint16_t)(a) >> 15))
+#define expF16UI(a) ((int_fast8_t)((a) >> 10) & 0x1F)
+#define fracF16UI(a) ((a)&0x03FF)
+#define packToF16UI(sign, exp, sig) (((uint16_t)(sign) << 15) + ((uint16_t)(exp) << 10) + (sig))
 
-#define isNaNF16UI( a ) (((~(a) & 0x7C00) == 0) && ((a) & 0x03FF))
+#define isNaNF16UI(a) (((~(a)&0x7C00) == 0) && ((a)&0x03FF))
 
-struct exp8_sig16 { int_fast8_t exp; uint_fast16_t sig; };
-struct exp8_sig16 softfloat_normSubnormalF16Sig( uint_fast16_t );
+struct exp8_sig16 {
+    int_fast8_t exp;
+    uint_fast16_t sig;
+};
+struct exp8_sig16 softfloat_normSubnormalF16Sig(uint_fast16_t);
 
-float16_t softfloat_roundPackToF16( bool, int_fast16_t, uint_fast16_t );
-float16_t softfloat_normRoundPackToF16( bool, int_fast16_t, uint_fast16_t );
+float16_t softfloat_roundPackToF16(bool, int_fast16_t, uint_fast16_t);
+float16_t softfloat_normRoundPackToF16(bool, int_fast16_t, uint_fast16_t);
 
-float16_t softfloat_addMagsF16( uint_fast16_t, uint_fast16_t );
-float16_t softfloat_subMagsF16( uint_fast16_t, uint_fast16_t );
-float16_t
- softfloat_mulAddF16(
-     uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t );
+float16_t softfloat_addMagsF16(uint_fast16_t, uint_fast16_t);
+float16_t softfloat_subMagsF16(uint_fast16_t, uint_fast16_t);
+float16_t softfloat_mulAddF16(uint_fast16_t, uint_fast16_t, uint_fast16_t, uint_fast8_t);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signBF16UI( a ) ((bool) ((uint16_t) (a)>>15))
-#define expBF16UI( a ) ((int_fast16_t) ((a)>>7) & 0xFF)
-#define fracBF16UI( a ) ((a) & 0x07F)
-#define packToBF16UI( sign, exp, sig ) (((uint16_t) (sign)<<15) + ((uint16_t) (exp)<<7) + (sig))
+ *----------------------------------------------------------------------------*/
+#define signBF16UI(a) ((bool)((uint16_t)(a) >> 15))
+#define expBF16UI(a) ((int_fast16_t)((a) >> 7) & 0xFF)
+#define fracBF16UI(a) ((a)&0x07F)
+#define packToBF16UI(sign, exp, sig) (((uint16_t)(sign) << 15) + ((uint16_t)(exp) << 7) + (sig))
 
-#define isNaNBF16UI( a ) (((~(a) & 0x7FC0) == 0) && ((a) & 0x07F))
+#define isNaNBF16UI(a) (((~(a)&0x7FC0) == 0) && ((a)&0x07F))
 
-bfloat16_t softfloat_roundPackToBF16( bool, int_fast16_t, uint_fast16_t );
-struct exp8_sig16 softfloat_normSubnormalBF16Sig( uint_fast16_t );
+bfloat16_t softfloat_roundPackToBF16(bool, int_fast16_t, uint_fast16_t);
+struct exp8_sig16 softfloat_normSubnormalBF16Sig(uint_fast16_t);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signF32UI( a ) ((bool) ((uint32_t) (a)>>31))
-#define expF32UI( a ) ((int_fast16_t) ((a)>>23) & 0xFF)
-#define fracF32UI( a ) ((a) & 0x007FFFFF)
-#define packToF32UI( sign, exp, sig ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<23) + (sig))
+ *----------------------------------------------------------------------------*/
+#define signF32UI(a) ((bool)((uint32_t)(a) >> 31))
+#define expF32UI(a) ((int_fast16_t)((a) >> 23) & 0xFF)
+#define fracF32UI(a) ((a)&0x007FFFFF)
+#define packToF32UI(sign, exp, sig) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 23) + (sig))
 
-#define isNaNF32UI( a ) (((~(a) & 0x7F800000) == 0) && ((a) & 0x007FFFFF))
+#define isNaNF32UI(a) (((~(a)&0x7F800000) == 0) && ((a)&0x007FFFFF))
 
-struct exp16_sig32 { int_fast16_t exp; uint_fast32_t sig; };
-struct exp16_sig32 softfloat_normSubnormalF32Sig( uint_fast32_t );
+struct exp16_sig32 {
+    int_fast16_t exp;
+    uint_fast32_t sig;
+};
+struct exp16_sig32 softfloat_normSubnormalF32Sig(uint_fast32_t);
 
-float32_t softfloat_roundPackToF32( bool, int_fast16_t, uint_fast32_t );
-float32_t softfloat_normRoundPackToF32( bool, int_fast16_t, uint_fast32_t );
+float32_t softfloat_roundPackToF32(bool, int_fast16_t, uint_fast32_t);
+float32_t softfloat_normRoundPackToF32(bool, int_fast16_t, uint_fast32_t);
 
-float32_t softfloat_addMagsF32( uint_fast32_t, uint_fast32_t );
-float32_t softfloat_subMagsF32( uint_fast32_t, uint_fast32_t );
-float32_t
- softfloat_mulAddF32(
-     uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t );
+float32_t softfloat_addMagsF32(uint_fast32_t, uint_fast32_t);
+float32_t softfloat_subMagsF32(uint_fast32_t, uint_fast32_t);
+float32_t softfloat_mulAddF32(uint_fast32_t, uint_fast32_t, uint_fast32_t, uint_fast8_t);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signF64UI( a ) ((bool) ((uint64_t) (a)>>63))
-#define expF64UI( a ) ((int_fast16_t) ((a)>>52) & 0x7FF)
-#define fracF64UI( a ) ((a) & UINT64_C( 0x000FFFFFFFFFFFFF ))
-#define packToF64UI( sign, exp, sig ) ((uint64_t) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<52) + (sig)))
+ *----------------------------------------------------------------------------*/
+#define signF64UI(a) ((bool)((uint64_t)(a) >> 63))
+#define expF64UI(a) ((int_fast16_t)((a) >> 52) & 0x7FF)
+#define fracF64UI(a) ((a)&UINT64_C(0x000FFFFFFFFFFFFF))
+#define packToF64UI(sign, exp, sig) ((uint64_t)(((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 52) + (sig)))
 
-#define isNaNF64UI( a ) (((~(a) & UINT64_C( 0x7FF0000000000000 )) == 0) && ((a) & UINT64_C( 0x000FFFFFFFFFFFFF )))
+#define isNaNF64UI(a) (((~(a)&UINT64_C(0x7FF0000000000000)) == 0) && ((a)&UINT64_C(0x000FFFFFFFFFFFFF)))
 
-struct exp16_sig64 { int_fast16_t exp; uint_fast64_t sig; };
-struct exp16_sig64 softfloat_normSubnormalF64Sig( uint_fast64_t );
+struct exp16_sig64 {
+    int_fast16_t exp;
+    uint_fast64_t sig;
+};
+struct exp16_sig64 softfloat_normSubnormalF64Sig(uint_fast64_t);
 
-float64_t softfloat_roundPackToF64( bool, int_fast16_t, uint_fast64_t );
-float64_t softfloat_normRoundPackToF64( bool, int_fast16_t, uint_fast64_t );
+float64_t softfloat_roundPackToF64(bool, int_fast16_t, uint_fast64_t);
+float64_t softfloat_normRoundPackToF64(bool, int_fast16_t, uint_fast64_t);
 
-float64_t softfloat_addMagsF64( uint_fast64_t, uint_fast64_t, bool );
-float64_t softfloat_subMagsF64( uint_fast64_t, uint_fast64_t, bool );
-float64_t
- softfloat_mulAddF64(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+float64_t softfloat_addMagsF64(uint_fast64_t, uint_fast64_t, bool);
+float64_t softfloat_subMagsF64(uint_fast64_t, uint_fast64_t, bool);
+float64_t softfloat_mulAddF64(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signExtF80UI64( a64 ) ((bool) ((uint16_t) (a64)>>15))
-#define expExtF80UI64( a64 ) ((a64) & 0x7FFF)
-#define packToExtF80UI64( sign, exp ) ((uint_fast16_t) (sign)<<15 | (exp))
+ *----------------------------------------------------------------------------*/
+#define signExtF80UI64(a64) ((bool)((uint16_t)(a64) >> 15))
+#define expExtF80UI64(a64) ((a64)&0x7FFF)
+#define packToExtF80UI64(sign, exp) ((uint_fast16_t)(sign) << 15 | (exp))
 
-#define isNaNExtF80UI( a64, a0 ) ((((a64) & 0x7FFF) == 0x7FFF) && ((a0) & UINT64_C( 0x7FFFFFFFFFFFFFFF )))
+#define isNaNExtF80UI(a64, a0) ((((a64)&0x7FFF) == 0x7FFF) && ((a0)&UINT64_C(0x7FFFFFFFFFFFFFFF)))
 
 #ifdef SOFTFLOAT_FAST_INT64
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
+ *----------------------------------------------------------------------------*/
 
-struct exp32_sig64 { int_fast32_t exp; uint64_t sig; };
-struct exp32_sig64 softfloat_normSubnormalExtF80Sig( uint_fast64_t );
+struct exp32_sig64 {
+    int_fast32_t exp;
+    uint64_t sig;
+};
+struct exp32_sig64 softfloat_normSubnormalExtF80Sig(uint_fast64_t);
 
-extFloat80_t
- softfloat_roundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
-extFloat80_t
- softfloat_normRoundPackToExtF80(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t );
+extFloat80_t softfloat_roundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
+extFloat80_t softfloat_normRoundPackToExtF80(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
 
-extFloat80_t
- softfloat_addMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
-extFloat80_t
- softfloat_subMagsExtF80(
-     uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool );
+extFloat80_t softfloat_addMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
+extFloat80_t softfloat_subMagsExtF80(uint_fast16_t, uint_fast64_t, uint_fast16_t, uint_fast64_t, bool);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signF128UI64( a64 ) ((bool) ((uint64_t) (a64)>>63))
-#define expF128UI64( a64 ) ((int_fast32_t) ((a64)>>48) & 0x7FFF)
-#define fracF128UI64( a64 ) ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))
-#define packToF128UI64( sign, exp, sig64 ) (((uint_fast64_t) (sign)<<63) + ((uint_fast64_t) (exp)<<48) + (sig64))
+ *----------------------------------------------------------------------------*/
+#define signF128UI64(a64) ((bool)((uint64_t)(a64) >> 63))
+#define expF128UI64(a64) ((int_fast32_t)((a64) >> 48) & 0x7FFF)
+#define fracF128UI64(a64) ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))
+#define packToF128UI64(sign, exp, sig64) (((uint_fast64_t)(sign) << 63) + ((uint_fast64_t)(exp) << 48) + (sig64))
 
-#define isNaNF128UI( a64, a0 ) (((~(a64) & UINT64_C( 0x7FFF000000000000 )) == 0) && (a0 || ((a64) & UINT64_C( 0x0000FFFFFFFFFFFF ))))
+#define isNaNF128UI(a64, a0) (((~(a64)&UINT64_C(0x7FFF000000000000)) == 0) && (a0 || ((a64)&UINT64_C(0x0000FFFFFFFFFFFF))))
 
-struct exp32_sig128 { int_fast32_t exp; struct uint128 sig; };
-struct exp32_sig128
- softfloat_normSubnormalF128Sig( uint_fast64_t, uint_fast64_t );
+struct exp32_sig128 {
+    int_fast32_t exp;
+    struct uint128 sig;
+};
+struct exp32_sig128 softfloat_normSubnormalF128Sig(uint_fast64_t, uint_fast64_t);
 
-float128_t
- softfloat_roundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t );
-float128_t
- softfloat_normRoundPackToF128(
-     bool, int_fast32_t, uint_fast64_t, uint_fast64_t );
+float128_t softfloat_roundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t, uint_fast64_t);
+float128_t softfloat_normRoundPackToF128(bool, int_fast32_t, uint_fast64_t, uint_fast64_t);
 
-float128_t
- softfloat_addMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-float128_t
- softfloat_subMagsF128(
-     uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool );
-float128_t
- softfloat_mulAddF128(
-     uint_fast64_t,
-     uint_fast64_t,
-     uint_fast64_t,
-     uint_fast64_t,
-     uint_fast64_t,
-     uint_fast64_t,
-     uint_fast8_t
- );
+float128_t softfloat_addMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
+float128_t softfloat_subMagsF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, bool);
+float128_t softfloat_mulAddF128(uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast64_t, uint_fast8_t);
 
 #else
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
+ *----------------------------------------------------------------------------*/
 
-bool
- softfloat_tryPropagateNaNExtF80M(
-     const struct extFloat80M *,
-     const struct extFloat80M *,
-     struct extFloat80M *
- );
-void softfloat_invalidExtF80M( struct extFloat80M * );
+bool softfloat_tryPropagateNaNExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*);
+void softfloat_invalidExtF80M(struct extFloat80M*);
 
-int softfloat_normExtF80SigM( uint64_t * );
+int softfloat_normExtF80SigM(uint64_t*);
 
-void
- softfloat_roundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
-void
- softfloat_normRoundPackMToExtF80M(
-     bool, int32_t, uint32_t *, uint_fast8_t, struct extFloat80M * );
+void softfloat_roundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
+void softfloat_normRoundPackMToExtF80M(bool, int32_t, uint32_t*, uint_fast8_t, struct extFloat80M*);
 
-void
- softfloat_addExtF80M(
-     const struct extFloat80M *,
-     const struct extFloat80M *,
-     struct extFloat80M *,
-     bool
- );
+void softfloat_addExtF80M(const struct extFloat80M*, const struct extFloat80M*, struct extFloat80M*, bool);
 
-int
- softfloat_compareNonnormExtF80M(
-     const struct extFloat80M *, const struct extFloat80M * );
+int softfloat_compareNonnormExtF80M(const struct extFloat80M*, const struct extFloat80M*);
 
 /*----------------------------------------------------------------------------
-*----------------------------------------------------------------------------*/
-#define signF128UI96( a96 ) ((bool) ((uint32_t) (a96)>>31))
-#define expF128UI96( a96 ) ((int32_t) ((a96)>>16) & 0x7FFF)
-#define fracF128UI96( a96 ) ((a96) & 0x0000FFFF)
-#define packToF128UI96( sign, exp, sig96 ) (((uint32_t) (sign)<<31) + ((uint32_t) (exp)<<16) + (sig96))
+ *----------------------------------------------------------------------------*/
+#define signF128UI96(a96) ((bool)((uint32_t)(a96) >> 31))
+#define expF128UI96(a96) ((int32_t)((a96) >> 16) & 0x7FFF)
+#define fracF128UI96(a96) ((a96)&0x0000FFFF)
+#define packToF128UI96(sign, exp, sig96) (((uint32_t)(sign) << 31) + ((uint32_t)(exp) << 16) + (sig96))
 
-bool softfloat_isNaNF128M( const uint32_t * );
+bool softfloat_isNaNF128M(const uint32_t*);
 
-bool
- softfloat_tryPropagateNaNF128M(
-     const uint32_t *, const uint32_t *, uint32_t * );
-void softfloat_invalidF128M( uint32_t * );
+bool softfloat_tryPropagateNaNF128M(const uint32_t*, const uint32_t*, uint32_t*);
+void softfloat_invalidF128M(uint32_t*);
 
-int softfloat_shiftNormSigF128M( const uint32_t *, uint_fast8_t, uint32_t * );
+int softfloat_shiftNormSigF128M(const uint32_t*, uint_fast8_t, uint32_t*);
 
-void softfloat_roundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
-void softfloat_normRoundPackMToF128M( bool, int32_t, uint32_t *, uint32_t * );
+void softfloat_roundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
+void softfloat_normRoundPackMToF128M(bool, int32_t, uint32_t*, uint32_t*);
 
-void
- softfloat_addF128M( const uint32_t *, const uint32_t *, uint32_t *, bool );
-void
- softfloat_mulAddF128M(
-     const uint32_t *,
-     const uint32_t *,
-     const uint32_t *,
-     uint32_t *,
-     uint_fast8_t
- );
+void softfloat_addF128M(const uint32_t*, const uint32_t*, uint32_t*, bool);
+void softfloat_mulAddF128M(const uint32_t*, const uint32_t*, const uint32_t*, uint32_t*, uint_fast8_t);
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/include/primitiveTypes.h b/softfloat/source/include/primitiveTypes.h
index e305400..b8348e3 100644
--- a/softfloat/source/include/primitiveTypes.h
+++ b/softfloat/source/include/primitiveTypes.h
@@ -42,13 +42,27 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef SOFTFLOAT_FAST_INT64
 
 #ifdef LITTLEENDIAN
-struct uint128 { uint64_t v0, v64; };
-struct uint64_extra { uint64_t extra, v; };
-struct uint128_extra { uint64_t extra; struct uint128 v; };
+struct uint128 {
+    uint64_t v0, v64;
+};
+struct uint64_extra {
+    uint64_t extra, v;
+};
+struct uint128_extra {
+    uint64_t extra;
+    struct uint128 v;
+};
 #else
-struct uint128 { uint64_t v64, v0; };
-struct uint64_extra { uint64_t v, extra; };
-struct uint128_extra { struct uint128 v; uint64_t extra; };
+struct uint128 {
+    uint64_t v64, v0;
+};
+struct uint64_extra {
+    uint64_t v, extra;
+};
+struct uint128_extra {
+    struct uint128 v;
+    uint64_t extra;
+};
 #endif
 
 #endif
@@ -59,27 +73,28 @@ struct uint128_extra { struct uint128 v; uint64_t extra; };
 *----------------------------------------------------------------------------*/
 #ifdef LITTLEENDIAN
 #define wordIncr 1
-#define indexWord( total, n ) (n)
-#define indexWordHi( total ) ((total) - 1)
-#define indexWordLo( total ) 0
-#define indexMultiword( total, m, n ) (n)
-#define indexMultiwordHi( total, n ) ((total) - (n))
-#define indexMultiwordLo( total, n ) 0
-#define indexMultiwordHiBut( total, n ) (n)
-#define indexMultiwordLoBut( total, n ) 0
-#define INIT_UINTM4( v3, v2, v1, v0 ) { v0, v1, v2, v3 }
+#define indexWord(total, n) (n)
+#define indexWordHi(total) ((total)-1)
+#define indexWordLo(total) 0
+#define indexMultiword(total, m, n) (n)
+#define indexMultiwordHi(total, n) ((total) - (n))
+#define indexMultiwordLo(total, n) 0
+#define indexMultiwordHiBut(total, n) (n)
+#define indexMultiwordLoBut(total, n) 0
+#define INIT_UINTM4(v3, v2, v1, v0)                                                                                                        \
+    { v0, v1, v2, v3 }
 #else
 #define wordIncr -1
-#define indexWord( total, n ) ((total) - 1 - (n))
-#define indexWordHi( total ) 0
-#define indexWordLo( total ) ((total) - 1)
-#define indexMultiword( total, m, n ) ((total) - 1 - (m))
-#define indexMultiwordHi( total, n ) 0
-#define indexMultiwordLo( total, n ) ((total) - (n))
-#define indexMultiwordHiBut( total, n ) 0
-#define indexMultiwordLoBut( total, n ) (n)
-#define INIT_UINTM4( v3, v2, v1, v0 ) { v3, v2, v1, v0 }
+#define indexWord(total, n) ((total)-1 - (n))
+#define indexWordHi(total) 0
+#define indexWordLo(total) ((total)-1)
+#define indexMultiword(total, m, n) ((total)-1 - (m))
+#define indexMultiwordHi(total, n) 0
+#define indexMultiwordLo(total, n) ((total) - (n))
+#define indexMultiwordHiBut(total, n) 0
+#define indexMultiwordLoBut(total, n) (n)
+#define INIT_UINTM4(v3, v2, v1, v0)                                                                                                        \
+    { v3, v2, v1, v0 }
 #endif
 
 #endif
-
diff --git a/softfloat/source/include/primitives.h b/softfloat/source/include/primitives.h
index 1084781..48c2596 100644
--- a/softfloat/source/include/primitives.h
+++ b/softfloat/source/include/primitives.h
@@ -37,9 +37,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef primitives_h
 #define primitives_h 1
 
+#include "primitiveTypes.h"
 #include <stdbool.h>
 #include <stdint.h>
-#include "primitiveTypes.h"
 
 #ifndef softfloat_shortShiftRightJam64
 /*----------------------------------------------------------------------------
@@ -50,10 +50,9 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist )
-    { return a>>dist | ((a & (((uint_fast64_t) 1<<dist) - 1)) != 0); }
+uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist) { return a >> dist | ((a & (((uint_fast64_t)1 << dist) - 1)) != 0); }
 #else
-uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist );
+uint64_t softfloat_shortShiftRightJam64(uint64_t a, uint_fast8_t dist);
 #endif
 #endif
 
@@ -68,13 +67,11 @@ uint64_t softfloat_shortShiftRightJam64( uint64_t a, uint_fast8_t dist );
 | is zero or nonzero.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist )
-{
-    return
-        (dist < 31) ? a>>dist | ((uint32_t) (a<<(-dist & 31)) != 0) : (a != 0);
+INLINE uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist) {
+    return (dist < 31) ? a >> dist | ((uint32_t)(a << (-dist & 31)) != 0) : (a != 0);
 }
 #else
-uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist );
+uint32_t softfloat_shiftRightJam32(uint32_t a, uint_fast16_t dist);
 #endif
 #endif
 
@@ -89,13 +86,11 @@ uint32_t softfloat_shiftRightJam32( uint32_t a, uint_fast16_t dist );
 | is zero or nonzero.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist )
-{
-    return
-        (dist < 63) ? a>>dist | ((uint64_t) (a<<(-dist & 63)) != 0) : (a != 0);
+INLINE uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist) {
+    return (dist < 63) ? a >> dist | ((uint64_t)(a << (-dist & 63)) != 0) : (a != 0);
 }
 #else
-uint64_t softfloat_shiftRightJam64( uint64_t a, uint_fast32_t dist );
+uint64_t softfloat_shiftRightJam64(uint64_t a, uint_fast32_t dist);
 #endif
 #endif
 
@@ -112,10 +107,9 @@ extern const uint_least8_t softfloat_countLeadingZeros8[256];
 | 'a'.  If 'a' is zero, 16 is returned.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
-INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
-{
+INLINE uint_fast8_t softfloat_countLeadingZeros16(uint16_t a) {
     uint_fast8_t count = 8;
-    if ( 0x100 <= a ) {
+    if(0x100 <= a) {
         count = 0;
         a >>= 8;
     }
@@ -123,7 +117,7 @@ INLINE uint_fast8_t softfloat_countLeadingZeros16( uint16_t a )
     return count;
 }
 #else
-uint_fast8_t softfloat_countLeadingZeros16( uint16_t a );
+uint_fast8_t softfloat_countLeadingZeros16(uint16_t a);
 #endif
 #endif
 
@@ -133,22 +127,21 @@ uint_fast8_t softfloat_countLeadingZeros16( uint16_t a );
 | 'a'.  If 'a' is zero, 32 is returned.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE uint_fast8_t softfloat_countLeadingZeros32( uint32_t a )
-{
+INLINE uint_fast8_t softfloat_countLeadingZeros32(uint32_t a) {
     uint_fast8_t count = 0;
-    if ( a < 0x10000 ) {
+    if(a < 0x10000) {
         count = 16;
         a <<= 16;
     }
-    if ( a < 0x1000000 ) {
+    if(a < 0x1000000) {
         count += 8;
         a <<= 8;
     }
-    count += softfloat_countLeadingZeros8[a>>24];
+    count += softfloat_countLeadingZeros8[a >> 24];
     return count;
 }
 #else
-uint_fast8_t softfloat_countLeadingZeros32( uint32_t a );
+uint_fast8_t softfloat_countLeadingZeros32(uint32_t a);
 #endif
 #endif
 
@@ -157,7 +150,7 @@ uint_fast8_t softfloat_countLeadingZeros32( uint32_t a );
 | Returns the number of leading 0 bits before the most-significant 1 bit of
 | 'a'.  If 'a' is zero, 64 is returned.
 *----------------------------------------------------------------------------*/
-uint_fast8_t softfloat_countLeadingZeros64( uint64_t a );
+uint_fast8_t softfloat_countLeadingZeros64(uint64_t a);
 #endif
 
 extern const uint16_t softfloat_approxRecip_1k0s[16];
@@ -176,9 +169,9 @@ extern const uint16_t softfloat_approxRecip_1k1s[16];
 | (units in the last place).
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_DIV64TO32
-#define softfloat_approxRecip32_1( a ) ((uint32_t) (UINT64_C( 0x7FFFFFFFFFFFFFFF ) / (uint32_t) (a)))
+#define softfloat_approxRecip32_1(a) ((uint32_t)(UINT64_C(0x7FFFFFFFFFFFFFFF) / (uint32_t)(a)))
 #else
-uint32_t softfloat_approxRecip32_1( uint32_t a );
+uint32_t softfloat_approxRecip32_1(uint32_t a);
 #endif
 #endif
 
@@ -204,7 +197,7 @@ extern const uint16_t softfloat_approxRecipSqrt_1k1s[16];
 | returned is also always within the range 0.5 to 1; thus, the most-
 | significant bit of the result is always set.
 *----------------------------------------------------------------------------*/
-uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );
+uint32_t softfloat_approxRecipSqrt32_1(unsigned int oddExpA, uint32_t a);
 #endif
 
 #ifdef SOFTFLOAT_FAST_INT64
@@ -222,10 +215,9 @@ uint32_t softfloat_approxRecipSqrt32_1( unsigned int oddExpA, uint32_t a );
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (1 <= INLINE_LEVEL)
 INLINE
-bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return (a64 == b64) && (a0 == b0); }
+bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 == b64) && (a0 == b0); }
 #else
-bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+bool softfloat_eq128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
 #endif
 #endif
 
@@ -237,10 +229,9 @@ bool softfloat_eq128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
+bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 <= b0)); }
 #else
-bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+bool softfloat_le128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
 #endif
 #endif
 
@@ -252,10 +243,9 @@ bool softfloat_le128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-    { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
+bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) { return (a64 < b64) || ((a64 == b64) && (a0 < b0)); }
 #else
-bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+bool softfloat_lt128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
 #endif
 #endif
 
@@ -266,17 +256,14 @@ bool softfloat_lt128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-struct uint128
- softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
+struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
     struct uint128 z;
-    z.v64 = a64<<dist | a0>>(-dist & 63);
-    z.v0 = a0<<dist;
+    z.v64 = a64 << dist | a0 >> (-dist & 63);
+    z.v0 = a0 << dist;
     return z;
 }
 #else
-struct uint128
- softfloat_shortShiftLeft128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
+struct uint128 softfloat_shortShiftLeft128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
 #endif
 #endif
 
@@ -287,17 +274,14 @@ struct uint128
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-struct uint128
- softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
+struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
     struct uint128 z;
-    z.v64 = a64>>dist;
-    z.v0 = a64<<(-dist & 63) | a0>>dist;
+    z.v64 = a64 >> dist;
+    z.v0 = a64 << (-dist & 63) | a0 >> dist;
     return z;
 }
 #else
-struct uint128
- softfloat_shortShiftRight128( uint64_t a64, uint64_t a0, uint_fast8_t dist );
+struct uint128 softfloat_shortShiftRight128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
 #endif
 #endif
 
@@ -308,19 +292,14 @@ struct uint128
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-struct uint64_extra
- softfloat_shortShiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast8_t dist )
-{
+struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist) {
     struct uint64_extra z;
-    z.v = a>>dist;
-    z.extra = a<<(-dist & 63) | (extra != 0);
+    z.v = a >> dist;
+    z.extra = a << (-dist & 63) | (extra != 0);
     return z;
 }
 #else
-struct uint64_extra
- softfloat_shortShiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast8_t dist );
+struct uint64_extra softfloat_shortShiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast8_t dist);
 #endif
 #endif
 
@@ -334,22 +313,15 @@ struct uint64_extra
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
 INLINE
-struct uint128
- softfloat_shortShiftRightJam128(
-     uint64_t a64, uint64_t a0, uint_fast8_t dist )
-{
+struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist) {
     uint_fast8_t negDist = -dist;
     struct uint128 z;
-    z.v64 = a64>>dist;
-    z.v0 =
-        a64<<(negDist & 63) | a0>>dist
-            | ((uint64_t) (a0<<(negDist & 63)) != 0);
+    z.v64 = a64 >> dist;
+    z.v0 = a64 << (negDist & 63) | a0 >> dist | ((uint64_t)(a0 << (negDist & 63)) != 0);
     return z;
 }
 #else
-struct uint128
- softfloat_shortShiftRightJam128(
-     uint64_t a64, uint64_t a0, uint_fast8_t dist );
+struct uint128 softfloat_shortShiftRightJam128(uint64_t a64, uint64_t a0, uint_fast8_t dist);
 #endif
 #endif
 
@@ -360,21 +332,16 @@ struct uint128
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
 INLINE
-struct uint128_extra
- softfloat_shortShiftRightJam128Extra(
-     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist )
-{
+struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist) {
     uint_fast8_t negDist = -dist;
     struct uint128_extra z;
-    z.v.v64 = a64>>dist;
-    z.v.v0 = a64<<(negDist & 63) | a0>>dist;
-    z.extra = a0<<(negDist & 63) | (extra != 0);
+    z.v.v64 = a64 >> dist;
+    z.v.v0 = a64 << (negDist & 63) | a0 >> dist;
+    z.extra = a0 << (negDist & 63) | (extra != 0);
     return z;
 }
 #else
-struct uint128_extra
- softfloat_shortShiftRightJam128Extra(
-     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist );
+struct uint128_extra softfloat_shortShiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast8_t dist);
 #endif
 #endif
 
@@ -397,14 +364,11 @@ struct uint128_extra
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
 INLINE
-struct uint64_extra
- softfloat_shiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast32_t dist )
-{
+struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist) {
     struct uint64_extra z;
-    if ( dist < 64 ) {
-        z.v = a>>dist;
-        z.extra = a<<(-dist & 63);
+    if(dist < 64) {
+        z.v = a >> dist;
+        z.extra = a << (-dist & 63);
     } else {
         z.v = 0;
         z.extra = (dist == 64) ? a : (a != 0);
@@ -413,9 +377,7 @@ struct uint64_extra
     return z;
 }
 #else
-struct uint64_extra
- softfloat_shiftRightJam64Extra(
-     uint64_t a, uint64_t extra, uint_fast32_t dist );
+struct uint64_extra softfloat_shiftRightJam64Extra(uint64_t a, uint64_t extra, uint_fast32_t dist);
 #endif
 #endif
 
@@ -430,8 +392,7 @@ struct uint64_extra
 | greater than 128, the result will be either 0 or 1, depending on whether the
 | original 128 bits are all zeros.
 *----------------------------------------------------------------------------*/
-struct uint128
- softfloat_shiftRightJam128( uint64_t a64, uint64_t a0, uint_fast32_t dist );
+struct uint128 softfloat_shiftRightJam128(uint64_t a64, uint64_t a0, uint_fast32_t dist);
 #endif
 
 #ifndef softfloat_shiftRightJam128Extra
@@ -452,9 +413,7 @@ struct uint128
 | is modified as described above and returned in the 'extra' field of the
 | result.)
 *----------------------------------------------------------------------------*/
-struct uint128_extra
- softfloat_shiftRightJam128Extra(
-     uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist );
+struct uint128_extra softfloat_shiftRightJam128Extra(uint64_t a64, uint64_t a0, uint64_t extra, uint_fast32_t dist);
 #endif
 
 #ifndef softfloat_shiftRightJam256M
@@ -470,9 +429,7 @@ struct uint128_extra
 | is greater than 256, the stored result will be either 0 or 1, depending on
 | whether the original 256 bits are all zeros.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shiftRightJam256M(
-     const uint64_t *aPtr, uint_fast32_t dist, uint64_t *zPtr );
+void softfloat_shiftRightJam256M(const uint64_t* aPtr, uint_fast32_t dist, uint64_t* zPtr);
 #endif
 
 #ifndef softfloat_add128
@@ -483,17 +440,14 @@ void
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-struct uint128
- softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
+struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
     struct uint128 z;
     z.v0 = a0 + b0;
     z.v64 = a64 + b64 + (z.v0 < a0);
     return z;
 }
 #else
-struct uint128
- softfloat_add128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+struct uint128 softfloat_add128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
 #endif
 #endif
 
@@ -505,9 +459,7 @@ struct uint128
 | an array of four 64-bit elements that concatenate in the platform's normal
 | endian order to form a 256-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_add256M(
-     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
+void softfloat_add256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
 #endif
 
 #ifndef softfloat_sub128
@@ -518,9 +470,7 @@ void
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-struct uint128
- softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 )
-{
+struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0) {
     struct uint128 z;
     z.v0 = a0 - b0;
     z.v64 = a64 - b64;
@@ -528,8 +478,7 @@ struct uint128
     return z;
 }
 #else
-struct uint128
- softfloat_sub128( uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0 );
+struct uint128 softfloat_sub128(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0);
 #endif
 #endif
 
@@ -542,9 +491,7 @@ struct uint128
 | 64-bit elements that concatenate in the platform's normal endian order to
 | form a 256-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_sub256M(
-     const uint64_t *aPtr, const uint64_t *bPtr, uint64_t *zPtr );
+void softfloat_sub256M(const uint64_t* aPtr, const uint64_t* bPtr, uint64_t* zPtr);
 #endif
 
 #ifndef softfloat_mul64ByShifted32To128
@@ -552,17 +499,16 @@ void
 | Returns the 128-bit product of 'a', 'b', and 2^32.
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (3 <= INLINE_LEVEL)
-INLINE struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b )
-{
+INLINE struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b) {
     uint_fast64_t mid;
     struct uint128 z;
-    mid = (uint_fast64_t) (uint32_t) a * b;
-    z.v0 = mid<<32;
-    z.v64 = (uint_fast64_t) (uint32_t) (a>>32) * b + (mid>>32);
+    mid = (uint_fast64_t)(uint32_t)a * b;
+    z.v0 = mid << 32;
+    z.v64 = (uint_fast64_t)(uint32_t)(a >> 32) * b + (mid >> 32);
     return z;
 }
 #else
-struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b );
+struct uint128 softfloat_mul64ByShifted32To128(uint64_t a, uint32_t b);
 #endif
 #endif
 
@@ -570,7 +516,7 @@ struct uint128 softfloat_mul64ByShifted32To128( uint64_t a, uint32_t b );
 /*----------------------------------------------------------------------------
 | Returns the 128-bit product of 'a' and 'b'.
 *----------------------------------------------------------------------------*/
-struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );
+struct uint128 softfloat_mul64To128(uint64_t a, uint64_t b);
 #endif
 
 #ifndef softfloat_mul128By32
@@ -581,19 +527,18 @@ struct uint128 softfloat_mul64To128( uint64_t a, uint64_t b );
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (4 <= INLINE_LEVEL)
 INLINE
-struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b )
-{
+struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b) {
     struct uint128 z;
     uint_fast64_t mid;
     uint_fast32_t carry;
     z.v0 = a0 * b;
-    mid = (uint_fast64_t) (uint32_t) (a0>>32) * b;
-    carry = (uint32_t) ((uint_fast32_t) (z.v0>>32) - (uint_fast32_t) mid);
-    z.v64 = a64 * b + (uint_fast32_t) ((mid + carry)>>32);
+    mid = (uint_fast64_t)(uint32_t)(a0 >> 32) * b;
+    carry = (uint32_t)((uint_fast32_t)(z.v0 >> 32) - (uint_fast32_t)mid);
+    z.v64 = a64 * b + (uint_fast32_t)((mid + carry) >> 32);
     return z;
 }
 #else
-struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b );
+struct uint128 softfloat_mul128By32(uint64_t a64, uint64_t a0, uint32_t b);
 #endif
 #endif
 
@@ -605,9 +550,7 @@ struct uint128 softfloat_mul128By32( uint64_t a64, uint64_t a0, uint32_t b );
 | Argument 'zPtr' points to an array of four 64-bit elements that concatenate
 | in the platform's normal endian order to form a 256-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_mul128To256M(
-     uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t *zPtr );
+void softfloat_mul128To256M(uint64_t a64, uint64_t a0, uint64_t b64, uint64_t b0, uint64_t* zPtr);
 #endif
 
 #else
@@ -626,7 +569,7 @@ void
 | Each of 'aPtr' and 'bPtr' points to an array of three 32-bit elements that
 | concatenate in the platform's normal endian order to form a 96-bit integer.
 *----------------------------------------------------------------------------*/
-int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr );
+int_fast8_t softfloat_compare96M(const uint32_t* aPtr, const uint32_t* bPtr);
 #endif
 
 #ifndef softfloat_compare128M
@@ -638,8 +581,7 @@ int_fast8_t softfloat_compare96M( const uint32_t *aPtr, const uint32_t *bPtr );
 | Each of 'aPtr' and 'bPtr' points to an array of four 32-bit elements that
 | concatenate in the platform's normal endian order to form a 128-bit integer.
 *----------------------------------------------------------------------------*/
-int_fast8_t
- softfloat_compare128M( const uint32_t *aPtr, const uint32_t *bPtr );
+int_fast8_t softfloat_compare128M(const uint32_t* aPtr, const uint32_t* bPtr);
 #endif
 
 #ifndef softfloat_shortShiftLeft64To96M
@@ -652,19 +594,14 @@ int_fast8_t
 *----------------------------------------------------------------------------*/
 #if defined INLINE_LEVEL && (2 <= INLINE_LEVEL)
 INLINE
-void
- softfloat_shortShiftLeft64To96M(
-     uint64_t a, uint_fast8_t dist, uint32_t *zPtr )
-{
-    zPtr[indexWord( 3, 0 )] = (uint32_t) a<<dist;
+void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr) {
+    zPtr[indexWord(3, 0)] = (uint32_t)a << dist;
     a >>= 32 - dist;
-    zPtr[indexWord( 3, 2 )] = a>>32;
-    zPtr[indexWord( 3, 1 )] = a;
+    zPtr[indexWord(3, 2)] = a >> 32;
+    zPtr[indexWord(3, 1)] = a;
 }
 #else
-void
- softfloat_shortShiftLeft64To96M(
-     uint64_t a, uint_fast8_t dist, uint32_t *zPtr );
+void softfloat_shortShiftLeft64To96M(uint64_t a, uint_fast8_t dist, uint32_t* zPtr);
 #endif
 #endif
 
@@ -678,13 +615,7 @@ void
 | that concatenate in the platform's normal endian order to form an N-bit
 | integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shortShiftLeftM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- );
+void softfloat_shortShiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_shortShiftLeft96M
@@ -692,7 +623,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftLeftM' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft96M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 3, aPtr, dist, zPtr )
+#define softfloat_shortShiftLeft96M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(3, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shortShiftLeft128M
@@ -700,7 +631,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftLeftM' with
 | 'size_words' = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft128M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 4, aPtr, dist, zPtr )
+#define softfloat_shortShiftLeft128M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(4, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shortShiftLeft160M
@@ -708,7 +639,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftLeftM' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftLeft160M( aPtr, dist, zPtr ) softfloat_shortShiftLeftM( 5, aPtr, dist, zPtr )
+#define softfloat_shortShiftLeft160M(aPtr, dist, zPtr) softfloat_shortShiftLeftM(5, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftLeftM
@@ -722,13 +653,7 @@ void
 |   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
 | greater than N, the stored result will be 0.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shiftLeftM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- );
+void softfloat_shiftLeftM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_shiftLeft96M
@@ -736,7 +661,7 @@ void
 | This function or macro is the same as 'softfloat_shiftLeftM' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft96M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 3, aPtr, dist, zPtr )
+#define softfloat_shiftLeft96M(aPtr, dist, zPtr) softfloat_shiftLeftM(3, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftLeft128M
@@ -744,7 +669,7 @@ void
 | This function or macro is the same as 'softfloat_shiftLeftM' with
 | 'size_words' = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft128M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 4, aPtr, dist, zPtr )
+#define softfloat_shiftLeft128M(aPtr, dist, zPtr) softfloat_shiftLeftM(4, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftLeft160M
@@ -752,7 +677,7 @@ void
 | This function or macro is the same as 'softfloat_shiftLeftM' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftLeft160M( aPtr, dist, zPtr ) softfloat_shiftLeftM( 5, aPtr, dist, zPtr )
+#define softfloat_shiftLeft160M(aPtr, dist, zPtr) softfloat_shiftLeftM(5, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shortShiftRightM
@@ -765,13 +690,7 @@ void
 | that concatenate in the platform's normal endian order to form an N-bit
 | integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shortShiftRightM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint_fast8_t dist,
-     uint32_t *zPtr
- );
+void softfloat_shortShiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint_fast8_t dist, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_shortShiftRight128M
@@ -779,7 +698,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftRightM' with
 | 'size_words' = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRight128M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 4, aPtr, dist, zPtr )
+#define softfloat_shortShiftRight128M(aPtr, dist, zPtr) softfloat_shortShiftRightM(4, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shortShiftRight160M
@@ -787,7 +706,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftRightM' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRight160M( aPtr, dist, zPtr ) softfloat_shortShiftRightM( 5, aPtr, dist, zPtr )
+#define softfloat_shortShiftRight160M(aPtr, dist, zPtr) softfloat_shortShiftRightM(5, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shortShiftRightJamM
@@ -801,9 +720,7 @@ void
 | to a 'size_words'-long array of 32-bit elements that concatenate in the
 | platform's normal endian order to form an N-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shortShiftRightJamM(
-     uint_fast8_t, const uint32_t *, uint_fast8_t, uint32_t * );
+void softfloat_shortShiftRightJamM(uint_fast8_t, const uint32_t*, uint_fast8_t, uint32_t*);
 #endif
 
 #ifndef softfloat_shortShiftRightJam160M
@@ -811,7 +728,7 @@ void
 | This function or macro is the same as 'softfloat_shortShiftRightJamM' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_shortShiftRightJam160M( aPtr, dist, zPtr ) softfloat_shortShiftRightJamM( 5, aPtr, dist, zPtr )
+#define softfloat_shortShiftRightJam160M(aPtr, dist, zPtr) softfloat_shortShiftRightJamM(5, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftRightM
@@ -825,13 +742,7 @@ void
 |   The value of 'dist' can be arbitrarily large.  In particular, if 'dist' is
 | greater than N, the stored result will be 0.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shiftRightM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- );
+void softfloat_shiftRightM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_shiftRight96M
@@ -839,7 +750,7 @@ void
 | This function or macro is the same as 'softfloat_shiftRightM' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftRight96M( aPtr, dist, zPtr ) softfloat_shiftRightM( 3, aPtr, dist, zPtr )
+#define softfloat_shiftRight96M(aPtr, dist, zPtr) softfloat_shiftRightM(3, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftRightJamM
@@ -856,13 +767,7 @@ void
 | is greater than N, the stored result will be either 0 or 1, depending on
 | whether the original N bits are all zeros.
 *----------------------------------------------------------------------------*/
-void
- softfloat_shiftRightJamM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     uint32_t dist,
-     uint32_t *zPtr
- );
+void softfloat_shiftRightJamM(uint_fast8_t size_words, const uint32_t* aPtr, uint32_t dist, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_shiftRightJam96M
@@ -870,7 +775,7 @@ void
 | This function or macro is the same as 'softfloat_shiftRightJamM' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam96M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 3, aPtr, dist, zPtr )
+#define softfloat_shiftRightJam96M(aPtr, dist, zPtr) softfloat_shiftRightJamM(3, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftRightJam128M
@@ -878,7 +783,7 @@ void
 | This function or macro is the same as 'softfloat_shiftRightJamM' with
 | 'size_words' = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam128M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 4, aPtr, dist, zPtr )
+#define softfloat_shiftRightJam128M(aPtr, dist, zPtr) softfloat_shiftRightJamM(4, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_shiftRightJam160M
@@ -886,7 +791,7 @@ void
 | This function or macro is the same as 'softfloat_shiftRightJamM' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_shiftRightJam160M( aPtr, dist, zPtr ) softfloat_shiftRightJamM( 5, aPtr, dist, zPtr )
+#define softfloat_shiftRightJam160M(aPtr, dist, zPtr) softfloat_shiftRightJamM(5, aPtr, dist, zPtr)
 #endif
 
 #ifndef softfloat_addM
@@ -898,13 +803,7 @@ void
 | elements that concatenate in the platform's normal endian order to form an
 | N-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_addM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint32_t *zPtr
- );
+void softfloat_addM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_add96M
@@ -912,7 +811,7 @@ void
 | This function or macro is the same as 'softfloat_addM' with 'size_words'
 | = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_add96M( aPtr, bPtr, zPtr ) softfloat_addM( 3, aPtr, bPtr, zPtr )
+#define softfloat_add96M(aPtr, bPtr, zPtr) softfloat_addM(3, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_add128M
@@ -920,7 +819,7 @@ void
 | This function or macro is the same as 'softfloat_addM' with 'size_words'
 | = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_add128M( aPtr, bPtr, zPtr ) softfloat_addM( 4, aPtr, bPtr, zPtr )
+#define softfloat_add128M(aPtr, bPtr, zPtr) softfloat_addM(4, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_add160M
@@ -928,7 +827,7 @@ void
 | This function or macro is the same as 'softfloat_addM' with 'size_words'
 | = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_add160M( aPtr, bPtr, zPtr ) softfloat_addM( 5, aPtr, bPtr, zPtr )
+#define softfloat_add160M(aPtr, bPtr, zPtr) softfloat_addM(5, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_addCarryM
@@ -940,14 +839,7 @@ void
 | points to a 'size_words'-long array of 32-bit elements that concatenate in
 | the platform's normal endian order to form an N-bit integer.
 *----------------------------------------------------------------------------*/
-uint_fast8_t
- softfloat_addCarryM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint_fast8_t carry,
-     uint32_t *zPtr
- );
+uint_fast8_t softfloat_addCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_addComplCarryM
@@ -956,14 +848,8 @@ uint_fast8_t
 | the value of the unsigned integer pointed to by 'bPtr' is bit-wise completed
 | before the addition.
 *----------------------------------------------------------------------------*/
-uint_fast8_t
- softfloat_addComplCarryM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint_fast8_t carry,
-     uint32_t *zPtr
- );
+uint_fast8_t softfloat_addComplCarryM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint_fast8_t carry,
+                                      uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_addComplCarry96M
@@ -971,7 +857,7 @@ uint_fast8_t
 | This function or macro is the same as 'softfloat_addComplCarryM' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_addComplCarry96M( aPtr, bPtr, carry, zPtr ) softfloat_addComplCarryM( 3, aPtr, bPtr, carry, zPtr )
+#define softfloat_addComplCarry96M(aPtr, bPtr, carry, zPtr) softfloat_addComplCarryM(3, aPtr, bPtr, carry, zPtr)
 #endif
 
 #ifndef softfloat_negXM
@@ -981,7 +867,7 @@ uint_fast8_t
 | points to a 'size_words'-long array of 32-bit elements that concatenate in
 | the platform's normal endian order to form an N-bit integer.
 *----------------------------------------------------------------------------*/
-void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
+void softfloat_negXM(uint_fast8_t size_words, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_negX96M
@@ -989,7 +875,7 @@ void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_negXM' with 'size_words'
 | = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_negX96M( zPtr ) softfloat_negXM( 3, zPtr )
+#define softfloat_negX96M(zPtr) softfloat_negXM(3, zPtr)
 #endif
 
 #ifndef softfloat_negX128M
@@ -997,7 +883,7 @@ void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_negXM' with 'size_words'
 | = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_negX128M( zPtr ) softfloat_negXM( 4, zPtr )
+#define softfloat_negX128M(zPtr) softfloat_negXM(4, zPtr)
 #endif
 
 #ifndef softfloat_negX160M
@@ -1005,7 +891,7 @@ void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_negXM' with 'size_words'
 | = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_negX160M( zPtr ) softfloat_negXM( 5, zPtr )
+#define softfloat_negX160M(zPtr) softfloat_negXM(5, zPtr)
 #endif
 
 #ifndef softfloat_negX256M
@@ -1013,7 +899,7 @@ void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_negXM' with 'size_words'
 | = 8 (N = 256).
 *----------------------------------------------------------------------------*/
-#define softfloat_negX256M( zPtr ) softfloat_negXM( 8, zPtr )
+#define softfloat_negX256M(zPtr) softfloat_negXM(8, zPtr)
 #endif
 
 #ifndef softfloat_sub1XM
@@ -1024,7 +910,7 @@ void softfloat_negXM( uint_fast8_t size_words, uint32_t *zPtr );
 | elements that concatenate in the platform's normal endian order to form an
 | N-bit integer.
 *----------------------------------------------------------------------------*/
-void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
+void softfloat_sub1XM(uint_fast8_t size_words, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_sub1X96M
@@ -1032,7 +918,7 @@ void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
 | = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_sub1X96M( zPtr ) softfloat_sub1XM( 3, zPtr )
+#define softfloat_sub1X96M(zPtr) softfloat_sub1XM(3, zPtr)
 #endif
 
 #ifndef softfloat_sub1X160M
@@ -1040,7 +926,7 @@ void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
 | This function or macro is the same as 'softfloat_sub1XM' with 'size_words'
 | = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_sub1X160M( zPtr ) softfloat_sub1XM( 5, zPtr )
+#define softfloat_sub1X160M(zPtr) softfloat_sub1XM(5, zPtr)
 #endif
 
 #ifndef softfloat_subM
@@ -1052,13 +938,7 @@ void softfloat_sub1XM( uint_fast8_t size_words, uint32_t *zPtr );
 | array of 32-bit elements that concatenate in the platform's normal endian
 | order to form an N-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_subM(
-     uint_fast8_t size_words,
-     const uint32_t *aPtr,
-     const uint32_t *bPtr,
-     uint32_t *zPtr
- );
+void softfloat_subM(uint_fast8_t size_words, const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_sub96M
@@ -1066,7 +946,7 @@ void
 | This function or macro is the same as 'softfloat_subM' with 'size_words'
 | = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_sub96M( aPtr, bPtr, zPtr ) softfloat_subM( 3, aPtr, bPtr, zPtr )
+#define softfloat_sub96M(aPtr, bPtr, zPtr) softfloat_subM(3, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_sub128M
@@ -1074,7 +954,7 @@ void
 | This function or macro is the same as 'softfloat_subM' with 'size_words'
 | = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_sub128M( aPtr, bPtr, zPtr ) softfloat_subM( 4, aPtr, bPtr, zPtr )
+#define softfloat_sub128M(aPtr, bPtr, zPtr) softfloat_subM(4, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_sub160M
@@ -1082,7 +962,7 @@ void
 | This function or macro is the same as 'softfloat_subM' with 'size_words'
 | = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_sub160M( aPtr, bPtr, zPtr ) softfloat_subM( 5, aPtr, bPtr, zPtr )
+#define softfloat_sub160M(aPtr, bPtr, zPtr) softfloat_subM(5, aPtr, bPtr, zPtr)
 #endif
 
 #ifndef softfloat_mul64To128M
@@ -1092,7 +972,7 @@ void
 | elements that concatenate in the platform's normal endian order to form a
 | 128-bit integer.
 *----------------------------------------------------------------------------*/
-void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr );
+void softfloat_mul64To128M(uint64_t a, uint64_t b, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_mul128MTo256M
@@ -1104,9 +984,7 @@ void softfloat_mul64To128M( uint64_t a, uint64_t b, uint32_t *zPtr );
 | Argument 'zPtr' points to an array of eight 32-bit elements that concatenate
 | to form a 256-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_mul128MTo256M(
-     const uint32_t *aPtr, const uint32_t *bPtr, uint32_t *zPtr );
+void softfloat_mul128MTo256M(const uint32_t* aPtr, const uint32_t* bPtr, uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_remStepMBy32
@@ -1119,15 +997,8 @@ void
 | to a 'size_words'-long array of 32-bit elements that concatenate in the
 | platform's normal endian order to form an N-bit integer.
 *----------------------------------------------------------------------------*/
-void
- softfloat_remStepMBy32(
-     uint_fast8_t size_words,
-     const uint32_t *remPtr,
-     uint_fast8_t dist,
-     const uint32_t *bPtr,
-     uint32_t q,
-     uint32_t *zPtr
- );
+void softfloat_remStepMBy32(uint_fast8_t size_words, const uint32_t* remPtr, uint_fast8_t dist, const uint32_t* bPtr, uint32_t q,
+                            uint32_t* zPtr);
 #endif
 
 #ifndef softfloat_remStep96MBy32
@@ -1135,7 +1006,7 @@ void
 | This function or macro is the same as 'softfloat_remStepMBy32' with
 | 'size_words' = 3 (N = 96).
 *----------------------------------------------------------------------------*/
-#define softfloat_remStep96MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 3, remPtr, dist, bPtr, q, zPtr )
+#define softfloat_remStep96MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(3, remPtr, dist, bPtr, q, zPtr)
 #endif
 
 #ifndef softfloat_remStep128MBy32
@@ -1143,7 +1014,7 @@ void
 | This function or macro is the same as 'softfloat_remStepMBy32' with
 | 'size_words' = 4 (N = 128).
 *----------------------------------------------------------------------------*/
-#define softfloat_remStep128MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 4, remPtr, dist, bPtr, q, zPtr )
+#define softfloat_remStep128MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(4, remPtr, dist, bPtr, q, zPtr)
 #endif
 
 #ifndef softfloat_remStep160MBy32
@@ -1151,10 +1022,9 @@ void
 | This function or macro is the same as 'softfloat_remStepMBy32' with
 | 'size_words' = 5 (N = 160).
 *----------------------------------------------------------------------------*/
-#define softfloat_remStep160MBy32( remPtr, dist, bPtr, q, zPtr ) softfloat_remStepMBy32( 5, remPtr, dist, bPtr, q, zPtr )
+#define softfloat_remStep160MBy32(remPtr, dist, bPtr, q, zPtr) softfloat_remStepMBy32(5, remPtr, dist, bPtr, q, zPtr)
 #endif
 
 #endif
 
 #endif
-
diff --git a/softfloat/source/include/softfloat.h b/softfloat/source/include/softfloat.h
index bf5014b..f3bed57 100644
--- a/softfloat/source/include/softfloat.h
+++ b/softfloat/source/include/softfloat.h
@@ -34,7 +34,6 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 =============================================================================*/
 
-
 /*============================================================================
 | Note:  If SoftFloat is made available as a general library for programs to
 | use, it is strongly recommended that a platform-specific version of this
@@ -42,13 +41,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | eliminates all dependencies on compile-time macros.
 *============================================================================*/
 
-
 #ifndef softfloat_h
 #define softfloat_h 1
 
+#include "softfloat_types.h"
 #include <stdbool.h>
 #include <stdint.h>
-#include "softfloat_types.h"
 
 #ifndef THREAD_LOCAL
 #define THREAD_LOCAL
@@ -58,10 +56,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | Software floating-point underflow tininess-detection mode.
 *----------------------------------------------------------------------------*/
 extern THREAD_LOCAL uint_fast8_t softfloat_detectTininess;
-enum {
-    softfloat_tininess_beforeRounding = 0,
-    softfloat_tininess_afterRounding  = 1
-};
+enum { softfloat_tininess_beforeRounding = 0, softfloat_tininess_afterRounding = 1 };
 
 /*----------------------------------------------------------------------------
 | Software floating-point rounding mode.  (Mode "odd" is supported only if
@@ -69,12 +64,12 @@ enum {
 *----------------------------------------------------------------------------*/
 extern THREAD_LOCAL uint_fast8_t softfloat_roundingMode;
 enum {
-    softfloat_round_near_even   = 0,
-    softfloat_round_minMag      = 1,
-    softfloat_round_min         = 2,
-    softfloat_round_max         = 3,
+    softfloat_round_near_even = 0,
+    softfloat_round_minMag = 1,
+    softfloat_round_min = 2,
+    softfloat_round_max = 3,
     softfloat_round_near_maxMag = 4,
-    softfloat_round_odd         = 6
+    softfloat_round_odd = 6
 };
 
 /*----------------------------------------------------------------------------
@@ -82,169 +77,169 @@ enum {
 *----------------------------------------------------------------------------*/
 extern THREAD_LOCAL uint_fast8_t softfloat_exceptionFlags;
 typedef enum {
-    softfloat_flag_inexact   =  1,
-    softfloat_flag_underflow =  2,
-    softfloat_flag_overflow  =  4,
-    softfloat_flag_infinite  =  8,
-    softfloat_flag_invalid   = 16
+    softfloat_flag_inexact = 1,
+    softfloat_flag_underflow = 2,
+    softfloat_flag_overflow = 4,
+    softfloat_flag_infinite = 8,
+    softfloat_flag_invalid = 16
 } exceptionFlag_t;
 
 /*----------------------------------------------------------------------------
 | Routine to raise any or all of the software floating-point exception flags.
 *----------------------------------------------------------------------------*/
-void softfloat_raiseFlags( uint_fast8_t );
+void softfloat_raiseFlags(uint_fast8_t);
 
 /*----------------------------------------------------------------------------
 | Integer-to-floating-point conversion routines.
 *----------------------------------------------------------------------------*/
-float16_t ui32_to_f16( uint32_t );
-float32_t ui32_to_f32( uint32_t );
-float64_t ui32_to_f64( uint32_t );
+float16_t ui32_to_f16(uint32_t);
+float32_t ui32_to_f32(uint32_t);
+float64_t ui32_to_f64(uint32_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui32_to_extF80( uint32_t );
-float128_t ui32_to_f128( uint32_t );
+extFloat80_t ui32_to_extF80(uint32_t);
+float128_t ui32_to_f128(uint32_t);
 #endif
-void ui32_to_extF80M( uint32_t, extFloat80_t * );
-void ui32_to_f128M( uint32_t, float128_t * );
-float16_t ui64_to_f16( uint64_t );
-float32_t ui64_to_f32( uint64_t );
-float64_t ui64_to_f64( uint64_t );
+void ui32_to_extF80M(uint32_t, extFloat80_t*);
+void ui32_to_f128M(uint32_t, float128_t*);
+float16_t ui64_to_f16(uint64_t);
+float32_t ui64_to_f32(uint64_t);
+float64_t ui64_to_f64(uint64_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t ui64_to_extF80( uint64_t );
-float128_t ui64_to_f128( uint64_t );
+extFloat80_t ui64_to_extF80(uint64_t);
+float128_t ui64_to_f128(uint64_t);
 #endif
-void ui64_to_extF80M( uint64_t, extFloat80_t * );
-void ui64_to_f128M( uint64_t, float128_t * );
-float16_t i32_to_f16( int32_t );
-float32_t i32_to_f32( int32_t );
-float64_t i32_to_f64( int32_t );
+void ui64_to_extF80M(uint64_t, extFloat80_t*);
+void ui64_to_f128M(uint64_t, float128_t*);
+float16_t i32_to_f16(int32_t);
+float32_t i32_to_f32(int32_t);
+float64_t i32_to_f64(int32_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i32_to_extF80( int32_t );
-float128_t i32_to_f128( int32_t );
+extFloat80_t i32_to_extF80(int32_t);
+float128_t i32_to_f128(int32_t);
 #endif
-void i32_to_extF80M( int32_t, extFloat80_t * );
-void i32_to_f128M( int32_t, float128_t * );
-float16_t i64_to_f16( int64_t );
-float32_t i64_to_f32( int64_t );
-float64_t i64_to_f64( int64_t );
+void i32_to_extF80M(int32_t, extFloat80_t*);
+void i32_to_f128M(int32_t, float128_t*);
+float16_t i64_to_f16(int64_t);
+float32_t i64_to_f32(int64_t);
+float64_t i64_to_f64(int64_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t i64_to_extF80( int64_t );
-float128_t i64_to_f128( int64_t );
+extFloat80_t i64_to_extF80(int64_t);
+float128_t i64_to_f128(int64_t);
 #endif
-void i64_to_extF80M( int64_t, extFloat80_t * );
-void i64_to_f128M( int64_t, float128_t * );
+void i64_to_extF80M(int64_t, extFloat80_t*);
+void i64_to_f128M(int64_t, float128_t*);
 
 /*----------------------------------------------------------------------------
 | 16-bit (half-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f16_to_ui32( float16_t, uint_fast8_t, bool );
-uint_fast64_t f16_to_ui64( float16_t, uint_fast8_t, bool );
-int_fast32_t f16_to_i32( float16_t, uint_fast8_t, bool );
-int_fast64_t f16_to_i64( float16_t, uint_fast8_t, bool );
-uint_fast32_t f16_to_ui32_r_minMag( float16_t, bool );
-uint_fast64_t f16_to_ui64_r_minMag( float16_t, bool );
-int_fast32_t f16_to_i32_r_minMag( float16_t, bool );
-int_fast64_t f16_to_i64_r_minMag( float16_t, bool );
-float32_t f16_to_f32( float16_t );
-float64_t f16_to_f64( float16_t );
+uint_fast32_t f16_to_ui32(float16_t, uint_fast8_t, bool);
+uint_fast64_t f16_to_ui64(float16_t, uint_fast8_t, bool);
+int_fast32_t f16_to_i32(float16_t, uint_fast8_t, bool);
+int_fast64_t f16_to_i64(float16_t, uint_fast8_t, bool);
+uint_fast32_t f16_to_ui32_r_minMag(float16_t, bool);
+uint_fast64_t f16_to_ui64_r_minMag(float16_t, bool);
+int_fast32_t f16_to_i32_r_minMag(float16_t, bool);
+int_fast64_t f16_to_i64_r_minMag(float16_t, bool);
+float32_t f16_to_f32(float16_t);
+float64_t f16_to_f64(float16_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f16_to_extF80( float16_t );
-float128_t f16_to_f128( float16_t );
+extFloat80_t f16_to_extF80(float16_t);
+float128_t f16_to_f128(float16_t);
 #endif
-void f16_to_extF80M( float16_t, extFloat80_t * );
-void f16_to_f128M( float16_t, float128_t * );
-float16_t f16_roundToInt( float16_t, uint_fast8_t, bool );
-float16_t f16_add( float16_t, float16_t );
-float16_t f16_sub( float16_t, float16_t );
-float16_t f16_mul( float16_t, float16_t );
-float16_t f16_mulAdd( float16_t, float16_t, float16_t );
-float16_t f16_div( float16_t, float16_t );
-float16_t f16_rem( float16_t, float16_t );
-float16_t f16_sqrt( float16_t );
-bool f16_eq( float16_t, float16_t );
-bool f16_le( float16_t, float16_t );
-bool f16_lt( float16_t, float16_t );
-bool f16_eq_signaling( float16_t, float16_t );
-bool f16_le_quiet( float16_t, float16_t );
-bool f16_lt_quiet( float16_t, float16_t );
-bool f16_isSignalingNaN( float16_t );
+void f16_to_extF80M(float16_t, extFloat80_t*);
+void f16_to_f128M(float16_t, float128_t*);
+float16_t f16_roundToInt(float16_t, uint_fast8_t, bool);
+float16_t f16_add(float16_t, float16_t);
+float16_t f16_sub(float16_t, float16_t);
+float16_t f16_mul(float16_t, float16_t);
+float16_t f16_mulAdd(float16_t, float16_t, float16_t);
+float16_t f16_div(float16_t, float16_t);
+float16_t f16_rem(float16_t, float16_t);
+float16_t f16_sqrt(float16_t);
+bool f16_eq(float16_t, float16_t);
+bool f16_le(float16_t, float16_t);
+bool f16_lt(float16_t, float16_t);
+bool f16_eq_signaling(float16_t, float16_t);
+bool f16_le_quiet(float16_t, float16_t);
+bool f16_lt_quiet(float16_t, float16_t);
+bool f16_isSignalingNaN(float16_t);
 
 /*----------------------------------------------------------------------------
 | 16-bit (brain float 16) floating-point operations.
 *----------------------------------------------------------------------------*/
-float32_t bf16_to_f32( bfloat16_t );
-bfloat16_t f32_to_bf16( float32_t );
-bool bf16_isSignalingNaN( bfloat16_t );
+float32_t bf16_to_f32(bfloat16_t);
+bfloat16_t f32_to_bf16(float32_t);
+bool bf16_isSignalingNaN(bfloat16_t);
 
 /*----------------------------------------------------------------------------
 | 32-bit (single-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f32_to_ui32( float32_t, uint_fast8_t, bool );
-uint_fast64_t f32_to_ui64( float32_t, uint_fast8_t, bool );
-int_fast32_t f32_to_i32( float32_t, uint_fast8_t, bool );
-int_fast64_t f32_to_i64( float32_t, uint_fast8_t, bool );
-uint_fast32_t f32_to_ui32_r_minMag( float32_t, bool );
-uint_fast64_t f32_to_ui64_r_minMag( float32_t, bool );
-int_fast32_t f32_to_i32_r_minMag( float32_t, bool );
-int_fast64_t f32_to_i64_r_minMag( float32_t, bool );
-float16_t f32_to_f16( float32_t );
-float64_t f32_to_f64( float32_t );
+uint_fast32_t f32_to_ui32(float32_t, uint_fast8_t, bool);
+uint_fast64_t f32_to_ui64(float32_t, uint_fast8_t, bool);
+int_fast32_t f32_to_i32(float32_t, uint_fast8_t, bool);
+int_fast64_t f32_to_i64(float32_t, uint_fast8_t, bool);
+uint_fast32_t f32_to_ui32_r_minMag(float32_t, bool);
+uint_fast64_t f32_to_ui64_r_minMag(float32_t, bool);
+int_fast32_t f32_to_i32_r_minMag(float32_t, bool);
+int_fast64_t f32_to_i64_r_minMag(float32_t, bool);
+float16_t f32_to_f16(float32_t);
+float64_t f32_to_f64(float32_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f32_to_extF80( float32_t );
-float128_t f32_to_f128( float32_t );
+extFloat80_t f32_to_extF80(float32_t);
+float128_t f32_to_f128(float32_t);
 #endif
-void f32_to_extF80M( float32_t, extFloat80_t * );
-void f32_to_f128M( float32_t, float128_t * );
-float32_t f32_roundToInt( float32_t, uint_fast8_t, bool );
-float32_t f32_add( float32_t, float32_t );
-float32_t f32_sub( float32_t, float32_t );
-float32_t f32_mul( float32_t, float32_t );
-float32_t f32_mulAdd( float32_t, float32_t, float32_t );
-float32_t f32_div( float32_t, float32_t );
-float32_t f32_rem( float32_t, float32_t );
-float32_t f32_sqrt( float32_t );
-bool f32_eq( float32_t, float32_t );
-bool f32_le( float32_t, float32_t );
-bool f32_lt( float32_t, float32_t );
-bool f32_eq_signaling( float32_t, float32_t );
-bool f32_le_quiet( float32_t, float32_t );
-bool f32_lt_quiet( float32_t, float32_t );
-bool f32_isSignalingNaN( float32_t );
+void f32_to_extF80M(float32_t, extFloat80_t*);
+void f32_to_f128M(float32_t, float128_t*);
+float32_t f32_roundToInt(float32_t, uint_fast8_t, bool);
+float32_t f32_add(float32_t, float32_t);
+float32_t f32_sub(float32_t, float32_t);
+float32_t f32_mul(float32_t, float32_t);
+float32_t f32_mulAdd(float32_t, float32_t, float32_t);
+float32_t f32_div(float32_t, float32_t);
+float32_t f32_rem(float32_t, float32_t);
+float32_t f32_sqrt(float32_t);
+bool f32_eq(float32_t, float32_t);
+bool f32_le(float32_t, float32_t);
+bool f32_lt(float32_t, float32_t);
+bool f32_eq_signaling(float32_t, float32_t);
+bool f32_le_quiet(float32_t, float32_t);
+bool f32_lt_quiet(float32_t, float32_t);
+bool f32_isSignalingNaN(float32_t);
 
 /*----------------------------------------------------------------------------
 | 64-bit (double-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
-uint_fast32_t f64_to_ui32( float64_t, uint_fast8_t, bool );
-uint_fast64_t f64_to_ui64( float64_t, uint_fast8_t, bool );
-int_fast32_t f64_to_i32( float64_t, uint_fast8_t, bool );
-int_fast64_t f64_to_i64( float64_t, uint_fast8_t, bool );
-uint_fast32_t f64_to_ui32_r_minMag( float64_t, bool );
-uint_fast64_t f64_to_ui64_r_minMag( float64_t, bool );
-int_fast32_t f64_to_i32_r_minMag( float64_t, bool );
-int_fast64_t f64_to_i64_r_minMag( float64_t, bool );
-float16_t f64_to_f16( float64_t );
-float32_t f64_to_f32( float64_t );
+uint_fast32_t f64_to_ui32(float64_t, uint_fast8_t, bool);
+uint_fast64_t f64_to_ui64(float64_t, uint_fast8_t, bool);
+int_fast32_t f64_to_i32(float64_t, uint_fast8_t, bool);
+int_fast64_t f64_to_i64(float64_t, uint_fast8_t, bool);
+uint_fast32_t f64_to_ui32_r_minMag(float64_t, bool);
+uint_fast64_t f64_to_ui64_r_minMag(float64_t, bool);
+int_fast32_t f64_to_i32_r_minMag(float64_t, bool);
+int_fast64_t f64_to_i64_r_minMag(float64_t, bool);
+float16_t f64_to_f16(float64_t);
+float32_t f64_to_f32(float64_t);
 #ifdef SOFTFLOAT_FAST_INT64
-extFloat80_t f64_to_extF80( float64_t );
-float128_t f64_to_f128( float64_t );
+extFloat80_t f64_to_extF80(float64_t);
+float128_t f64_to_f128(float64_t);
 #endif
-void f64_to_extF80M( float64_t, extFloat80_t * );
-void f64_to_f128M( float64_t, float128_t * );
-float64_t f64_roundToInt( float64_t, uint_fast8_t, bool );
-float64_t f64_add( float64_t, float64_t );
-float64_t f64_sub( float64_t, float64_t );
-float64_t f64_mul( float64_t, float64_t );
-float64_t f64_mulAdd( float64_t, float64_t, float64_t );
-float64_t f64_div( float64_t, float64_t );
-float64_t f64_rem( float64_t, float64_t );
-float64_t f64_sqrt( float64_t );
-bool f64_eq( float64_t, float64_t );
-bool f64_le( float64_t, float64_t );
-bool f64_lt( float64_t, float64_t );
-bool f64_eq_signaling( float64_t, float64_t );
-bool f64_le_quiet( float64_t, float64_t );
-bool f64_lt_quiet( float64_t, float64_t );
-bool f64_isSignalingNaN( float64_t );
+void f64_to_extF80M(float64_t, extFloat80_t*);
+void f64_to_f128M(float64_t, float128_t*);
+float64_t f64_roundToInt(float64_t, uint_fast8_t, bool);
+float64_t f64_add(float64_t, float64_t);
+float64_t f64_sub(float64_t, float64_t);
+float64_t f64_mul(float64_t, float64_t);
+float64_t f64_mulAdd(float64_t, float64_t, float64_t);
+float64_t f64_div(float64_t, float64_t);
+float64_t f64_rem(float64_t, float64_t);
+float64_t f64_sqrt(float64_t);
+bool f64_eq(float64_t, float64_t);
+bool f64_le(float64_t, float64_t);
+bool f64_lt(float64_t, float64_t);
+bool f64_eq_signaling(float64_t, float64_t);
+bool f64_le_quiet(float64_t, float64_t);
+bool f64_lt_quiet(float64_t, float64_t);
+bool f64_isSignalingNaN(float64_t);
 
 /*----------------------------------------------------------------------------
 | Rounding precision for 80-bit extended double-precision floating-point.
@@ -256,124 +251,118 @@ extern THREAD_LOCAL uint_fast8_t extF80_roundingPrecision;
 | 80-bit extended double-precision floating-point operations.
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t extF80_to_ui32( extFloat80_t, uint_fast8_t, bool );
-uint_fast64_t extF80_to_ui64( extFloat80_t, uint_fast8_t, bool );
-int_fast32_t extF80_to_i32( extFloat80_t, uint_fast8_t, bool );
-int_fast64_t extF80_to_i64( extFloat80_t, uint_fast8_t, bool );
-uint_fast32_t extF80_to_ui32_r_minMag( extFloat80_t, bool );
-uint_fast64_t extF80_to_ui64_r_minMag( extFloat80_t, bool );
-int_fast32_t extF80_to_i32_r_minMag( extFloat80_t, bool );
-int_fast64_t extF80_to_i64_r_minMag( extFloat80_t, bool );
-float16_t extF80_to_f16( extFloat80_t );
-float32_t extF80_to_f32( extFloat80_t );
-float64_t extF80_to_f64( extFloat80_t );
-float128_t extF80_to_f128( extFloat80_t );
-extFloat80_t extF80_roundToInt( extFloat80_t, uint_fast8_t, bool );
-extFloat80_t extF80_add( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sub( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_mul( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_div( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_rem( extFloat80_t, extFloat80_t );
-extFloat80_t extF80_sqrt( extFloat80_t );
-bool extF80_eq( extFloat80_t, extFloat80_t );
-bool extF80_le( extFloat80_t, extFloat80_t );
-bool extF80_lt( extFloat80_t, extFloat80_t );
-bool extF80_eq_signaling( extFloat80_t, extFloat80_t );
-bool extF80_le_quiet( extFloat80_t, extFloat80_t );
-bool extF80_lt_quiet( extFloat80_t, extFloat80_t );
-bool extF80_isSignalingNaN( extFloat80_t );
+uint_fast32_t extF80_to_ui32(extFloat80_t, uint_fast8_t, bool);
+uint_fast64_t extF80_to_ui64(extFloat80_t, uint_fast8_t, bool);
+int_fast32_t extF80_to_i32(extFloat80_t, uint_fast8_t, bool);
+int_fast64_t extF80_to_i64(extFloat80_t, uint_fast8_t, bool);
+uint_fast32_t extF80_to_ui32_r_minMag(extFloat80_t, bool);
+uint_fast64_t extF80_to_ui64_r_minMag(extFloat80_t, bool);
+int_fast32_t extF80_to_i32_r_minMag(extFloat80_t, bool);
+int_fast64_t extF80_to_i64_r_minMag(extFloat80_t, bool);
+float16_t extF80_to_f16(extFloat80_t);
+float32_t extF80_to_f32(extFloat80_t);
+float64_t extF80_to_f64(extFloat80_t);
+float128_t extF80_to_f128(extFloat80_t);
+extFloat80_t extF80_roundToInt(extFloat80_t, uint_fast8_t, bool);
+extFloat80_t extF80_add(extFloat80_t, extFloat80_t);
+extFloat80_t extF80_sub(extFloat80_t, extFloat80_t);
+extFloat80_t extF80_mul(extFloat80_t, extFloat80_t);
+extFloat80_t extF80_div(extFloat80_t, extFloat80_t);
+extFloat80_t extF80_rem(extFloat80_t, extFloat80_t);
+extFloat80_t extF80_sqrt(extFloat80_t);
+bool extF80_eq(extFloat80_t, extFloat80_t);
+bool extF80_le(extFloat80_t, extFloat80_t);
+bool extF80_lt(extFloat80_t, extFloat80_t);
+bool extF80_eq_signaling(extFloat80_t, extFloat80_t);
+bool extF80_le_quiet(extFloat80_t, extFloat80_t);
+bool extF80_lt_quiet(extFloat80_t, extFloat80_t);
+bool extF80_isSignalingNaN(extFloat80_t);
 #endif
-uint_fast32_t extF80M_to_ui32( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast64_t extF80M_to_ui64( const extFloat80_t *, uint_fast8_t, bool );
-int_fast32_t extF80M_to_i32( const extFloat80_t *, uint_fast8_t, bool );
-int_fast64_t extF80M_to_i64( const extFloat80_t *, uint_fast8_t, bool );
-uint_fast32_t extF80M_to_ui32_r_minMag( const extFloat80_t *, bool );
-uint_fast64_t extF80M_to_ui64_r_minMag( const extFloat80_t *, bool );
-int_fast32_t extF80M_to_i32_r_minMag( const extFloat80_t *, bool );
-int_fast64_t extF80M_to_i64_r_minMag( const extFloat80_t *, bool );
-float16_t extF80M_to_f16( const extFloat80_t * );
-float32_t extF80M_to_f32( const extFloat80_t * );
-float64_t extF80M_to_f64( const extFloat80_t * );
-void extF80M_to_f128M( const extFloat80_t *, float128_t * );
-void
- extF80M_roundToInt(
-     const extFloat80_t *, uint_fast8_t, bool, extFloat80_t * );
-void extF80M_add( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sub( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_mul( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_div( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_rem( const extFloat80_t *, const extFloat80_t *, extFloat80_t * );
-void extF80M_sqrt( const extFloat80_t *, extFloat80_t * );
-bool extF80M_eq( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_eq_signaling( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_le_quiet( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_lt_quiet( const extFloat80_t *, const extFloat80_t * );
-bool extF80M_isSignalingNaN( const extFloat80_t * );
+uint_fast32_t extF80M_to_ui32(const extFloat80_t*, uint_fast8_t, bool);
+uint_fast64_t extF80M_to_ui64(const extFloat80_t*, uint_fast8_t, bool);
+int_fast32_t extF80M_to_i32(const extFloat80_t*, uint_fast8_t, bool);
+int_fast64_t extF80M_to_i64(const extFloat80_t*, uint_fast8_t, bool);
+uint_fast32_t extF80M_to_ui32_r_minMag(const extFloat80_t*, bool);
+uint_fast64_t extF80M_to_ui64_r_minMag(const extFloat80_t*, bool);
+int_fast32_t extF80M_to_i32_r_minMag(const extFloat80_t*, bool);
+int_fast64_t extF80M_to_i64_r_minMag(const extFloat80_t*, bool);
+float16_t extF80M_to_f16(const extFloat80_t*);
+float32_t extF80M_to_f32(const extFloat80_t*);
+float64_t extF80M_to_f64(const extFloat80_t*);
+void extF80M_to_f128M(const extFloat80_t*, float128_t*);
+void extF80M_roundToInt(const extFloat80_t*, uint_fast8_t, bool, extFloat80_t*);
+void extF80M_add(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
+void extF80M_sub(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
+void extF80M_mul(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
+void extF80M_div(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
+void extF80M_rem(const extFloat80_t*, const extFloat80_t*, extFloat80_t*);
+void extF80M_sqrt(const extFloat80_t*, extFloat80_t*);
+bool extF80M_eq(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_le(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_lt(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_eq_signaling(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_le_quiet(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_lt_quiet(const extFloat80_t*, const extFloat80_t*);
+bool extF80M_isSignalingNaN(const extFloat80_t*);
 
 /*----------------------------------------------------------------------------
 | 128-bit (quadruple-precision) floating-point operations.
 *----------------------------------------------------------------------------*/
 #ifdef SOFTFLOAT_FAST_INT64
-uint_fast32_t f128_to_ui32( float128_t, uint_fast8_t, bool );
-uint_fast64_t f128_to_ui64( float128_t, uint_fast8_t, bool );
-int_fast32_t f128_to_i32( float128_t, uint_fast8_t, bool );
-int_fast64_t f128_to_i64( float128_t, uint_fast8_t, bool );
-uint_fast32_t f128_to_ui32_r_minMag( float128_t, bool );
-uint_fast64_t f128_to_ui64_r_minMag( float128_t, bool );
-int_fast32_t f128_to_i32_r_minMag( float128_t, bool );
-int_fast64_t f128_to_i64_r_minMag( float128_t, bool );
-float16_t f128_to_f16( float128_t );
-float32_t f128_to_f32( float128_t );
-float64_t f128_to_f64( float128_t );
-extFloat80_t f128_to_extF80( float128_t );
-float128_t f128_roundToInt( float128_t, uint_fast8_t, bool );
-float128_t f128_add( float128_t, float128_t );
-float128_t f128_sub( float128_t, float128_t );
-float128_t f128_mul( float128_t, float128_t );
-float128_t f128_mulAdd( float128_t, float128_t, float128_t );
-float128_t f128_div( float128_t, float128_t );
-float128_t f128_rem( float128_t, float128_t );
-float128_t f128_sqrt( float128_t );
-bool f128_eq( float128_t, float128_t );
-bool f128_le( float128_t, float128_t );
-bool f128_lt( float128_t, float128_t );
-bool f128_eq_signaling( float128_t, float128_t );
-bool f128_le_quiet( float128_t, float128_t );
-bool f128_lt_quiet( float128_t, float128_t );
-bool f128_isSignalingNaN( float128_t );
+uint_fast32_t f128_to_ui32(float128_t, uint_fast8_t, bool);
+uint_fast64_t f128_to_ui64(float128_t, uint_fast8_t, bool);
+int_fast32_t f128_to_i32(float128_t, uint_fast8_t, bool);
+int_fast64_t f128_to_i64(float128_t, uint_fast8_t, bool);
+uint_fast32_t f128_to_ui32_r_minMag(float128_t, bool);
+uint_fast64_t f128_to_ui64_r_minMag(float128_t, bool);
+int_fast32_t f128_to_i32_r_minMag(float128_t, bool);
+int_fast64_t f128_to_i64_r_minMag(float128_t, bool);
+float16_t f128_to_f16(float128_t);
+float32_t f128_to_f32(float128_t);
+float64_t f128_to_f64(float128_t);
+extFloat80_t f128_to_extF80(float128_t);
+float128_t f128_roundToInt(float128_t, uint_fast8_t, bool);
+float128_t f128_add(float128_t, float128_t);
+float128_t f128_sub(float128_t, float128_t);
+float128_t f128_mul(float128_t, float128_t);
+float128_t f128_mulAdd(float128_t, float128_t, float128_t);
+float128_t f128_div(float128_t, float128_t);
+float128_t f128_rem(float128_t, float128_t);
+float128_t f128_sqrt(float128_t);
+bool f128_eq(float128_t, float128_t);
+bool f128_le(float128_t, float128_t);
+bool f128_lt(float128_t, float128_t);
+bool f128_eq_signaling(float128_t, float128_t);
+bool f128_le_quiet(float128_t, float128_t);
+bool f128_lt_quiet(float128_t, float128_t);
+bool f128_isSignalingNaN(float128_t);
 #endif
-uint_fast32_t f128M_to_ui32( const float128_t *, uint_fast8_t, bool );
-uint_fast64_t f128M_to_ui64( const float128_t *, uint_fast8_t, bool );
-int_fast32_t f128M_to_i32( const float128_t *, uint_fast8_t, bool );
-int_fast64_t f128M_to_i64( const float128_t *, uint_fast8_t, bool );
-uint_fast32_t f128M_to_ui32_r_minMag( const float128_t *, bool );
-uint_fast64_t f128M_to_ui64_r_minMag( const float128_t *, bool );
-int_fast32_t f128M_to_i32_r_minMag( const float128_t *, bool );
-int_fast64_t f128M_to_i64_r_minMag( const float128_t *, bool );
-float16_t f128M_to_f16( const float128_t * );
-float32_t f128M_to_f32( const float128_t * );
-float64_t f128M_to_f64( const float128_t * );
-void f128M_to_extF80M( const float128_t *, extFloat80_t * );
-void f128M_roundToInt( const float128_t *, uint_fast8_t, bool, float128_t * );
-void f128M_add( const float128_t *, const float128_t *, float128_t * );
-void f128M_sub( const float128_t *, const float128_t *, float128_t * );
-void f128M_mul( const float128_t *, const float128_t *, float128_t * );
-void
- f128M_mulAdd(
-     const float128_t *, const float128_t *, const float128_t *, float128_t *
- );
-void f128M_div( const float128_t *, const float128_t *, float128_t * );
-void f128M_rem( const float128_t *, const float128_t *, float128_t * );
-void f128M_sqrt( const float128_t *, float128_t * );
-bool f128M_eq( const float128_t *, const float128_t * );
-bool f128M_le( const float128_t *, const float128_t * );
-bool f128M_lt( const float128_t *, const float128_t * );
-bool f128M_eq_signaling( const float128_t *, const float128_t * );
-bool f128M_le_quiet( const float128_t *, const float128_t * );
-bool f128M_lt_quiet( const float128_t *, const float128_t * );
-bool f128M_isSignalingNaN( const float128_t * );
+uint_fast32_t f128M_to_ui32(const float128_t*, uint_fast8_t, bool);
+uint_fast64_t f128M_to_ui64(const float128_t*, uint_fast8_t, bool);
+int_fast32_t f128M_to_i32(const float128_t*, uint_fast8_t, bool);
+int_fast64_t f128M_to_i64(const float128_t*, uint_fast8_t, bool);
+uint_fast32_t f128M_to_ui32_r_minMag(const float128_t*, bool);
+uint_fast64_t f128M_to_ui64_r_minMag(const float128_t*, bool);
+int_fast32_t f128M_to_i32_r_minMag(const float128_t*, bool);
+int_fast64_t f128M_to_i64_r_minMag(const float128_t*, bool);
+float16_t f128M_to_f16(const float128_t*);
+float32_t f128M_to_f32(const float128_t*);
+float64_t f128M_to_f64(const float128_t*);
+void f128M_to_extF80M(const float128_t*, extFloat80_t*);
+void f128M_roundToInt(const float128_t*, uint_fast8_t, bool, float128_t*);
+void f128M_add(const float128_t*, const float128_t*, float128_t*);
+void f128M_sub(const float128_t*, const float128_t*, float128_t*);
+void f128M_mul(const float128_t*, const float128_t*, float128_t*);
+void f128M_mulAdd(const float128_t*, const float128_t*, const float128_t*, float128_t*);
+void f128M_div(const float128_t*, const float128_t*, float128_t*);
+void f128M_rem(const float128_t*, const float128_t*, float128_t*);
+void f128M_sqrt(const float128_t*, float128_t*);
+bool f128M_eq(const float128_t*, const float128_t*);
+bool f128M_le(const float128_t*, const float128_t*);
+bool f128M_lt(const float128_t*, const float128_t*);
+bool f128M_eq_signaling(const float128_t*, const float128_t*);
+bool f128M_le_quiet(const float128_t*, const float128_t*);
+bool f128M_lt_quiet(const float128_t*, const float128_t*);
+bool f128M_isSignalingNaN(const float128_t*);
 
 #endif
-
diff --git a/softfloat/source/include/softfloat_types.h b/softfloat/source/include/softfloat_types.h
index 25039b5..9ed5809 100644
--- a/softfloat/source/include/softfloat_types.h
+++ b/softfloat/source/include/softfloat_types.h
@@ -47,11 +47,21 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 | the types below may, if desired, be defined as aliases for the native types
 | (typically 'float' and 'double', and possibly 'long double').
 *----------------------------------------------------------------------------*/
-typedef struct { uint16_t v; } float16_t;
-typedef struct { uint16_t v; } bfloat16_t;
-typedef struct { uint32_t v; } float32_t;
-typedef struct { uint64_t v; } float64_t;
-typedef struct { uint64_t v[2]; } float128_t;
+typedef struct {
+    uint16_t v;
+} float16_t;
+typedef struct {
+    uint16_t v;
+} bfloat16_t;
+typedef struct {
+    uint32_t v;
+} float32_t;
+typedef struct {
+    uint64_t v;
+} float64_t;
+typedef struct {
+    uint64_t v[2];
+} float128_t;
 
 /*----------------------------------------------------------------------------
 | The format of an 80-bit extended floating-point number in memory.  This
@@ -59,9 +69,15 @@ typedef struct { uint64_t v[2]; } float128_t;
 | named 'signif'.
 *----------------------------------------------------------------------------*/
 #ifdef LITTLEENDIAN
-struct extFloat80M { uint64_t signif; uint16_t signExp; };
+struct extFloat80M {
+    uint64_t signif;
+    uint16_t signExp;
+};
 #else
-struct extFloat80M { uint16_t signExp; uint64_t signif; };
+struct extFloat80M {
+    uint16_t signExp;
+    uint64_t signif;
+};
 #endif
 
 /*----------------------------------------------------------------------------
@@ -79,4 +95,3 @@ struct extFloat80M { uint16_t signExp; uint64_t signif; };
 typedef struct extFloat80M extFloat80_t;
 
 #endif
-

From 42efced1eb0b2efbc3b8ed0c5e2a7171a9215f6b Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 2 Aug 2024 08:59:22 +0200
Subject: [PATCH 059/100] fixes FCSR behavior if no floating point is
 implemented

---
 src/iss/arch/riscv_hart_m_p.h    | 112 ++++++++++++++--------------
 src/iss/arch/riscv_hart_msu_vp.h |   2 +
 src/iss/arch/riscv_hart_mu_p.h   | 121 ++++++++++++++++++-------------
 3 files changed, 129 insertions(+), 106 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index ed59015..c3311fd 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -377,8 +377,8 @@ protected:
 
     std::vector<uint8_t> tcm;
 
-    iss::status read_csr_reg(unsigned addr, reg_t& val);
-    iss::status write_csr_reg(unsigned addr, reg_t val);
+    iss::status read_plain(unsigned addr, reg_t& val);
+    iss::status write_plain(unsigned addr, reg_t val);
     iss::status read_null(unsigned addr, reg_t& val);
     iss::status write_null(unsigned addr, reg_t val) { return iss::status::Ok; }
     iss::status read_cycle(unsigned addr, reg_t& val);
@@ -399,17 +399,19 @@ protected:
     iss::status read_intstatus(unsigned addr, reg_t& val);
     iss::status write_intthresh(unsigned addr, reg_t val);
     iss::status write_xtvt(unsigned addr, reg_t val);
-    iss::status write_dcsr_dcsr(unsigned addr, reg_t val);
-    iss::status read_dcsr_reg(unsigned addr, reg_t& val);
-    iss::status write_dcsr_reg(unsigned addr, reg_t val);
-    iss::status read_dpc_reg(unsigned addr, reg_t& val);
-    iss::status write_dpc_reg(unsigned addr, reg_t val);
+    iss::status write_dcsr(unsigned addr, reg_t val);
+    iss::status read_debug(unsigned addr, reg_t& val);
+    iss::status write_dscratch(unsigned addr, reg_t val);
+    iss::status read_dpc(unsigned addr, reg_t& val);
+    iss::status write_dpc(unsigned addr, reg_t val);
+    iss::status read_fcsr(unsigned addr, reg_t& val);
+    iss::status write_fcsr(unsigned addr, reg_t val);
 
-    virtual iss::status read_custom_csr_reg(unsigned addr, reg_t& val) { return iss::status::Err; };
-    virtual iss::status write_custom_csr_reg(unsigned addr, reg_t val) { return iss::status::Err; };
+    virtual iss::status read_custom_csr(unsigned addr, reg_t& val) { return iss::status::Err; };
+    virtual iss::status write_custom_csr(unsigned addr, reg_t val) { return iss::status::Err; };
 
-    void register_custom_csr_rd(unsigned addr) { csr_rd_cb[addr] = &this_class::read_custom_csr_reg; }
-    void register_custom_csr_wr(unsigned addr) { csr_wr_cb[addr] = &this_class::write_custom_csr_reg; }
+    void register_custom_csr_rd(unsigned addr) { csr_rd_cb[addr] = &this_class::read_custom_csr; }
+    void register_custom_csr_wr(unsigned addr) { csr_wr_cb[addr] = &this_class::write_custom_csr; }
 
     reg_t mhartid_reg{0x0};
 
@@ -446,18 +448,21 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
     csr[mimpid] = 1;
 
     uart_buf.str("");
+    if(traits<BASE>::FLEN > 0)
+        csr_rd_cb[fcsr] = &this_class::read_fcsr;
+    csr_wr_cb[fcsr] = &this_class::write_fcsr;
     for(unsigned addr = mhpmcounter3; addr <= mhpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     if(traits<BASE>::XLEN == 32)
         for(unsigned addr = mhpmcounter3h; addr <= mhpmcounter31h; ++addr) {
             csr_rd_cb[addr] = &this_class::read_null;
-            csr_wr_cb[addr] = &this_class::write_csr_reg;
+            csr_wr_cb[addr] = &this_class::write_plain;
         }
     for(unsigned addr = mhpmevent3; addr <= mhpmevent31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     for(unsigned addr = hpmcounter3; addr <= hpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
@@ -465,18 +470,17 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
     if(traits<BASE>::XLEN == 32)
         for(unsigned addr = hpmcounter3h; addr <= hpmcounter31h; ++addr) {
             csr_rd_cb[addr] = &this_class::read_null;
-            // csr_wr_cb[addr] = &this_class::write_csr_reg;
         }
     // common regs
     const std::array<unsigned, 4> roaddrs{{misa, mvendorid, marchid, mimpid}};
     for(auto addr : roaddrs) {
-        csr_rd_cb[addr] = &this_class::read_csr_reg;
+        csr_rd_cb[addr] = &this_class::read_plain;
         csr_wr_cb[addr] = &this_class::write_null;
     }
     const std::array<unsigned, 4> rwaddrs{{mepc, mtvec, mscratch, mtval}};
     for(auto addr : rwaddrs) {
-        csr_rd_cb[addr] = &this_class::read_csr_reg;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_rd_cb[addr] = &this_class::read_plain;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     // special handling & overrides
     csr_rd_cb[time] = &this_class::read_time;
@@ -517,7 +521,7 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
     csr_wr_cb[marchid] = &this_class::write_null;
     csr_wr_cb[mimpid] = &this_class::write_null;
     if(FEAT & FEAT_CLIC) {
-        csr_rd_cb[mtvt] = &this_class::read_csr_reg;
+        csr_rd_cb[mtvt] = &this_class::read_plain;
         csr_wr_cb[mtvt] = &this_class::write_xtvt;
         //        csr_rd_cb[mxnti] = &this_class::read_csr_reg;
         //        csr_wr_cb[mxnti] = &this_class::write_csr_reg;
@@ -527,7 +531,7 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
         //        csr_wr_cb[mscratchcsw] = &this_class::write_csr_reg;
         //        csr_rd_cb[mscratchcswl] = &this_class::read_csr_reg;
         //        csr_wr_cb[mscratchcswl] = &this_class::write_csr_reg;
-        csr_rd_cb[mintthresh] = &this_class::read_csr_reg;
+        csr_rd_cb[mintthresh] = &this_class::read_plain;
         csr_wr_cb[mintthresh] = &this_class::write_intthresh;
         clic_int_reg.resize(cfg.clic_num_irq, clic_int_reg_t{.raw = 0});
         clic_cfg_reg = 0x20;
@@ -553,14 +557,14 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
         insert_mem_range(cfg.tcm_base, cfg.tcm_size, read_clic_cb, write_clic_cb);
     }
     if(FEAT & FEAT_DEBUG) {
-        csr_wr_cb[dscratch0] = &this_class::write_dcsr_reg;
-        csr_rd_cb[dscratch0] = &this_class::read_dcsr_reg;
-        csr_wr_cb[dscratch1] = &this_class::write_dcsr_reg;
-        csr_rd_cb[dscratch1] = &this_class::read_dcsr_reg;
-        csr_wr_cb[dpc] = &this_class::write_dpc_reg;
-        csr_rd_cb[dpc] = &this_class::read_dpc_reg;
-        csr_wr_cb[dcsr] = &this_class::write_dcsr_dcsr;
-        csr_rd_cb[dcsr] = &this_class::read_dcsr_reg;
+        csr_wr_cb[dscratch0] = &this_class::write_dscratch;
+        csr_rd_cb[dscratch0] = &this_class::read_debug;
+        csr_wr_cb[dscratch1] = &this_class::write_dscratch;
+        csr_rd_cb[dscratch1] = &this_class::read_debug;
+        csr_wr_cb[dpc] = &this_class::write_dpc;
+        csr_rd_cb[dpc] = &this_class::read_dpc;
+        csr_wr_cb[dcsr] = &this_class::write_dcsr;
+        csr_rd_cb[dcsr] = &this_class::read_debug;
     }
     hart_mem_rd_delegate = [this](phys_addr_t a, unsigned l, uint8_t* const d) -> iss::status { return this->read_mem(a, l, d); };
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
@@ -665,7 +669,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
                 }
                 phys_addr_t phys_addr{access, space, addr};
                 auto res = iss::Err;
-                if(access != access_type::FETCH && memfn_range.size()) {
+                if(!is_fetch(access) && memfn_range.size()) {
                     auto it =
                         std::find_if(std::begin(memfn_range), std::end(memfn_range), [phys_addr](std::tuple<uint64_t, uint64_t> const& a) {
                             return std::get<0>(a) <= phys_addr.val && (std::get<0>(a) + std::get<1>(a)) > phys_addr.val;
@@ -692,11 +696,6 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
         case traits<BASE>::CSR: {
             if(length != sizeof(reg_t))
                 return iss::Err;
-            // We emulate the FCSR in the architectural state
-            if(addr == 3) {
-                *data = this->get_fcsr();
-                return iss::Ok;
-            }
             return read_csr(addr, *reinterpret_cast<reg_t* const>(data));
         } break;
         case traits<BASE>::FENCE: {
@@ -767,7 +766,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
                 }
                 phys_addr_t phys_addr{access, space, addr};
                 auto res = iss::Err;
-                if(access != access_type::FETCH && memfn_range.size()) {
+                if(!is_fetch(access) && memfn_range.size()) {
                     auto it =
                         std::find_if(std::begin(memfn_range), std::end(memfn_range), [phys_addr](std::tuple<uint64_t, uint64_t> const& a) {
                             return std::get<0>(a) <= phys_addr.val && (std::get<0>(a) + std::get<1>(a)) > phys_addr.val;
@@ -798,8 +797,6 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
             case 0x10023000: // UART1 base, TXFIFO reg
                 uart_buf << (char)data[0];
                 if(((char)data[0]) == '\n' || data[0] == 0) {
-                    // CPPLOG(INFO)<<"UART"<<((paddr.val>>16)&0x3)<<" send
-                    // '"<<uart_buf.str()<<"'";
                     std::cout << uart_buf.str();
                     uart_buf.str("");
                 }
@@ -828,11 +825,6 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
         case traits<BASE>::CSR: {
             if(length != sizeof(reg_t))
                 return iss::Err;
-            // We emulate the FCSR in the architectural state
-            if(addr == 3) {
-                this->set_fcsr(*data);
-                return iss::Ok;
-            }
             return write_csr(addr, *reinterpret_cast<const reg_t*>(data));
         } break;
         case traits<BASE>::FENCE: {
@@ -889,12 +881,6 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t v
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
-    val = csr[addr];
-    return iss::Ok;
-}
-
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
@@ -902,7 +888,13 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t&
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_plain(unsigned addr, reg_t& val) {
+    val = csr[addr];
+    return iss::Ok;
+}
+
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_plain(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
@@ -1052,7 +1044,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t v
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1064,7 +1056,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, r
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_debug(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
@@ -1072,7 +1064,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dscratch(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
@@ -1080,7 +1072,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, re
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
@@ -1088,7 +1080,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_dpc(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
@@ -1101,6 +1093,18 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, re
     return iss::Ok;
 }
 
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_fcsr(unsigned addr, reg_t& val) {
+    val = this->get_fcsr();
+    return iss::Ok;
+}
+
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_fcsr(unsigned addr, reg_t val) {
+    this->set_fcsr(val);
+    return iss::Ok;
+}
+
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index fd1b844..66cdc1b 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -39,7 +39,9 @@
 #include "iss/instrumentation_if.h"
 #include "iss/log_categories.h"
 #include "iss/vm_if.h"
+#include "iss/vm_types.h"
 #include "riscv_hart_common.h"
+#include <stdexcept>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 09a213b..d3d0a09 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -39,7 +39,9 @@
 #include "iss/instrumentation_if.h"
 #include "iss/log_categories.h"
 #include "iss/vm_if.h"
+#include "iss/vm_types.h"
 #include "riscv_hart_common.h"
+#include <stdexcept>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
@@ -302,8 +304,8 @@ public:
     void set_mhartid(reg_t mhartid) { mhartid_reg = mhartid; };
 
     void disass_output(uint64_t pc, const std::string instr) override {
-        CLOG(INFO, disass) << fmt::format("0x{:016x}    {:40} [p:{};s:0x{:x};c:{}]", pc, instr, lvl[this->reg.PRIV], (reg_t)state.mstatus,
-                                          this->reg.icount + cycle_offset);
+        NSCLOG(INFO, LOGCAT) << fmt::format("0x{:016x}    {:40} [p:{};s:0x{:x};c:{}]", pc, instr, lvl[this->reg.PRIV], (reg_t)state.mstatus,
+                                            this->reg.icount + cycle_offset);
     };
 
     iss::instrumentation_if* get_instrumentation_if() override { return &instr_if; }
@@ -402,8 +404,8 @@ protected:
 
     std::vector<uint8_t> tcm;
 
-    iss::status read_csr_reg(unsigned addr, reg_t& val);
-    iss::status write_csr_reg(unsigned addr, reg_t val);
+    iss::status read_plain(unsigned addr, reg_t& val);
+    iss::status write_plain(unsigned addr, reg_t val);
     iss::status read_null(unsigned addr, reg_t& val);
     iss::status write_null(unsigned addr, reg_t val) { return iss::status::Ok; }
     iss::status read_cycle(unsigned addr, reg_t& val);
@@ -426,15 +428,17 @@ protected:
     iss::status read_intstatus(unsigned addr, reg_t& val);
     iss::status write_intthresh(unsigned addr, reg_t val);
     iss::status write_xtvt(unsigned addr, reg_t val);
-    iss::status write_dcsr_dcsr(unsigned addr, reg_t val);
-    iss::status read_dcsr_reg(unsigned addr, reg_t& val);
-    iss::status write_dcsr_reg(unsigned addr, reg_t val);
-    iss::status read_dpc_reg(unsigned addr, reg_t& val);
-    iss::status write_dpc_reg(unsigned addr, reg_t val);
-    iss::status write_pmpcfg_reg(unsigned addr, reg_t val);
+    iss::status write_dcsr(unsigned addr, reg_t val);
+    iss::status read_debug(unsigned addr, reg_t& val);
+    iss::status write_dscratch(unsigned addr, reg_t val);
+    iss::status read_dpc(unsigned addr, reg_t& val);
+    iss::status write_dpc(unsigned addr, reg_t val);
+    iss::status read_fcsr(unsigned addr, reg_t& val);
+    iss::status write_fcsr(unsigned addr, reg_t val);
+    iss::status write_pmpcfg(unsigned addr, reg_t val);
 
-    virtual iss::status read_custom_csr_reg(unsigned addr, reg_t& val) { return iss::status::Err; };
-    virtual iss::status write_custom_csr_reg(unsigned addr, reg_t val) { return iss::status::Err; };
+    virtual iss::status read_custom_csr(unsigned addr, reg_t& val) { return iss::status::Err; };
+    virtual iss::status write_custom_csr(unsigned addr, reg_t val) { return iss::status::Err; };
 
     void register_custom_csr_rd(unsigned addr) { csr_rd_cb[addr] = &this_class::read_custom_csr_reg; }
     void register_custom_csr_wr(unsigned addr) { csr_wr_cb[addr] = &this_class::write_custom_csr_reg; }
@@ -474,18 +478,21 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
     csr[mimpid] = 1;
 
     uart_buf.str("");
+    if(traits<BASE>::FLEN > 0)
+        csr_rd_cb[fcsr] = &this_class::read_fcsr;
+    csr_wr_cb[fcsr] = &this_class::write_fcsr;
     for(unsigned addr = mhpmcounter3; addr <= mhpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     if(traits<BASE>::XLEN == 32)
         for(unsigned addr = mhpmcounter3h; addr <= mhpmcounter31h; ++addr) {
             csr_rd_cb[addr] = &this_class::read_null;
-            csr_wr_cb[addr] = &this_class::write_csr_reg;
+            csr_wr_cb[addr] = &this_class::write_plain;
         }
     for(unsigned addr = mhpmevent3; addr <= mhpmevent31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     for(unsigned addr = hpmcounter3; addr <= hpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
@@ -493,12 +500,11 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
     if(traits<BASE>::XLEN == 32)
         for(unsigned addr = hpmcounter3h; addr <= hpmcounter31h; ++addr) {
             csr_rd_cb[addr] = &this_class::read_null;
-            // csr_wr_cb[addr] = &this_class::write_csr_reg;
         }
     // common regs
     const std::array<unsigned, 4> roaddrs{{misa, mvendorid, marchid, mimpid}};
     for(auto addr : roaddrs) {
-        csr_rd_cb[addr] = &this_class::read_csr_reg;
+        csr_rd_cb[addr] = &this_class::read_plain;
         csr_wr_cb[addr] = &this_class::write_null;
     }
     const std::array<unsigned, 8> rwaddrs{{
@@ -512,8 +518,8 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
         utval,
     }};
     for(auto addr : rwaddrs) {
-        csr_rd_cb[addr] = &this_class::read_csr_reg;
-        csr_wr_cb[addr] = &this_class::write_csr_reg;
+        csr_rd_cb[addr] = &this_class::read_plain;
+        csr_wr_cb[addr] = &this_class::write_plain;
     }
     // special handling & overrides
     csr_rd_cb[time] = &this_class::read_time;
@@ -558,18 +564,18 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
 
     if(FEAT & FEAT_PMP) {
         for(size_t i = pmpaddr0; i <= pmpaddr15; ++i) {
-            csr_rd_cb[i] = &this_class::read_csr_reg;
-            csr_wr_cb[i] = &this_class::write_csr_reg;
+            csr_rd_cb[i] = &this_class::read_plain;
+            csr_wr_cb[i] = &this_class::write_plain;
         }
         for(size_t i = pmpcfg0; i < pmpcfg0 + 16 / sizeof(reg_t); ++i) {
-            csr_rd_cb[i] = &this_class::read_csr_reg;
-            csr_wr_cb[i] = &this_class::write_pmpcfg_reg;
+            csr_rd_cb[i] = &this_class::read_plain;
+            csr_wr_cb[i] = &this_class::write_pmpcfg;
         }
     }
     if(FEAT & FEAT_EXT_N) {
-        csr_rd_cb[mideleg] = &this_class::read_csr_reg;
+        csr_rd_cb[mideleg] = &this_class::read_plain;
         csr_wr_cb[mideleg] = &this_class::write_ideleg;
-        csr_rd_cb[medeleg] = &this_class::read_csr_reg;
+        csr_rd_cb[medeleg] = &this_class::read_plain;
         csr_wr_cb[medeleg] = &this_class::write_edeleg;
         csr_rd_cb[uie] = &this_class::read_ie;
         csr_wr_cb[uie] = &this_class::write_ie;
@@ -583,7 +589,7 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
         csr_rd_cb[utvec] = &this_class::read_tvec;
     }
     if(FEAT & FEAT_CLIC) {
-        csr_rd_cb[mtvt] = &this_class::read_csr_reg;
+        csr_rd_cb[mtvt] = &this_class::read_plain;
         csr_wr_cb[mtvt] = &this_class::write_xtvt;
         //        csr_rd_cb[mxnti] = &this_class::read_csr_reg;
         //        csr_wr_cb[mxnti] = &this_class::write_csr_reg;
@@ -593,14 +599,14 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
         //        csr_wr_cb[mscratchcsw] = &this_class::write_csr_reg;
         //        csr_rd_cb[mscratchcswl] = &this_class::read_csr_reg;
         //        csr_wr_cb[mscratchcswl] = &this_class::write_csr_reg;
-        csr_rd_cb[mintthresh] = &this_class::read_csr_reg;
+        csr_rd_cb[mintthresh] = &this_class::read_plain;
         csr_wr_cb[mintthresh] = &this_class::write_intthresh;
         if(FEAT & FEAT_EXT_N) {
-            csr_rd_cb[utvt] = &this_class::read_csr_reg;
+            csr_rd_cb[utvt] = &this_class::read_plain;
             csr_wr_cb[utvt] = &this_class::write_xtvt;
             csr_rd_cb[uintstatus] = &this_class::read_intstatus;
             csr_wr_cb[uintstatus] = &this_class::write_null;
-            csr_rd_cb[uintthresh] = &this_class::read_csr_reg;
+            csr_rd_cb[uintthresh] = &this_class::read_plain;
             csr_wr_cb[uintthresh] = &this_class::write_intthresh;
         }
         clic_int_reg.resize(cfg.clic_num_irq, clic_int_reg_t{.raw = 0});
@@ -629,14 +635,14 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
         insert_mem_range(cfg.tcm_base, cfg.tcm_size, read_clic_cb, write_clic_cb);
     }
     if(FEAT & FEAT_DEBUG) {
-        csr_wr_cb[dscratch0] = &this_class::write_dcsr_reg;
-        csr_rd_cb[dscratch0] = &this_class::read_dcsr_reg;
-        csr_wr_cb[dscratch1] = &this_class::write_dcsr_reg;
-        csr_rd_cb[dscratch1] = &this_class::read_dcsr_reg;
-        csr_wr_cb[dpc] = &this_class::write_dpc_reg;
-        csr_rd_cb[dpc] = &this_class::read_dpc_reg;
-        csr_wr_cb[dcsr] = &this_class::write_dcsr_dcsr;
-        csr_rd_cb[dcsr] = &this_class::read_dcsr_reg;
+        csr_wr_cb[dscratch0] = &this_class::write_dscratch;
+        csr_rd_cb[dscratch0] = &this_class::read_debug;
+        csr_wr_cb[dscratch1] = &this_class::write_dscratch;
+        csr_rd_cb[dscratch1] = &this_class::read_debug;
+        csr_wr_cb[dpc] = &this_class::write_dpc;
+        csr_rd_cb[dpc] = &this_class::read_dpc;
+        csr_wr_cb[dcsr] = &this_class::write_dcsr;
+        csr_rd_cb[dcsr] = &this_class::read_debug;
     }
     hart_mem_rd_delegate = [this](phys_addr_t a, unsigned l, uint8_t* const d) -> iss::status { return this->read_mem(a, l, d); };
     hart_mem_wr_delegate = [this](phys_addr_t a, unsigned l, uint8_t const* const d) -> iss::status { return this->write_mem(a, l, d); };
@@ -725,7 +731,7 @@ inline void riscv_hart_mu_p<BASE, FEAT, LOGCAT>::insert_mem_range(uint64_t base,
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-inline iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_pmpcfg_reg(unsigned addr, reg_t val) {
+inline iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_pmpcfg(unsigned addr, reg_t val) {
     csr[addr] = val & 0x9f9f9f9f;
     return iss::Ok;
 }
@@ -988,8 +994,6 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type,
             case 0x10023000: // UART1 base, TXFIFO reg
                 uart_buf << (char)data[0];
                 if(((char)data[0]) == '\n' || data[0] == 0) {
-                    // CPPLOG(INFO)<<"UART"<<((addr>>16)&0x3)<<" send
-                    // '"<<uart_buf.str()<<"'";
                     std::cout << uart_buf.str();
                     uart_buf.str("");
                 }
@@ -1074,12 +1078,6 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr(unsigned addr, reg_t
     return (this->*(it->second))(addr, val);
 }
 
-template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_csr_reg(unsigned addr, reg_t& val) {
-    val = csr[addr];
-    return iss::Ok;
-}
-
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t& val) {
     val = 0;
@@ -1087,7 +1085,13 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_null(unsigned addr, reg_t&
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_csr_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_plain(unsigned addr, reg_t& val) {
+    val = csr[addr];
+    return iss::Ok;
+}
+
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_plain(unsigned addr, reg_t val) {
     csr[addr] = val;
     return iss::Ok;
 }
@@ -1161,6 +1165,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_tvec(unsigned addr, reg_t&
     val = FEAT & features_e::FEAT_CLIC ? csr[addr] : csr[addr] & ~2;
     return iss::Ok;
 }
+
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_status(unsigned addr, reg_t& val) {
     val = state.mstatus & hart_state_type::get_mask((addr >> 8) & 0x3);
@@ -1272,7 +1277,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_epc(unsigned addr, reg_t
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr, reg_t val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     //                  +-------------- ebreakm
@@ -1284,7 +1289,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_dcsr(unsigned addr,
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, reg_t& val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_debug(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = csr[addr];
@@ -1292,7 +1297,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dcsr_reg(unsigned addr, re
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dscratch(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     csr[addr] = val;
@@ -1300,7 +1305,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dcsr_reg(unsigned addr, r
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg_t& val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc(unsigned addr, reg_t& val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     val = this->reg.DPC;
@@ -1308,7 +1313,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_dpc_reg(unsigned addr, reg
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
-iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dpc_reg(unsigned addr, reg_t val) {
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_dpc(unsigned addr, reg_t val) {
     if(!debug_mode_active())
         throw illegal_instruction_fault(this->fault_data);
     this->reg.DPC = val;
@@ -1324,6 +1329,18 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_intstatus(unsigned addr, r
     return iss::Ok;
 }
 
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_fcsr(unsigned addr, reg_t& val) {
+    val = this->get_fcsr();
+    return iss::Ok;
+}
+
+template <typename BASE, features_e FEAT, typename LOGCAT>
+iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_fcsr(unsigned addr, reg_t val) {
+    this->set_fcsr(val);
+    return iss::Ok;
+}
+
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_intthresh(unsigned addr, reg_t val) {
     csr[addr] = (val & 0xff) | (1 << (cfg.clic_int_ctl_bits)) - 1;

From edf456c59f9e5a7f69966e4ea6f2583d16ca3719 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 2 Aug 2024 10:33:15 +0200
Subject: [PATCH 060/100] fixes missing braces

---
 src/iss/arch/riscv_hart_m_p.h  | 5 +++--
 src/iss/arch/riscv_hart_mu_p.h | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index c3311fd..f808891 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -448,9 +448,10 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
     csr[mimpid] = 1;
 
     uart_buf.str("");
-    if(traits<BASE>::FLEN > 0)
+    if(traits<BASE>::FLEN > 0) {
         csr_rd_cb[fcsr] = &this_class::read_fcsr;
-    csr_wr_cb[fcsr] = &this_class::write_fcsr;
+        csr_wr_cb[fcsr] = &this_class::write_fcsr;
+    }
     for(unsigned addr = mhpmcounter3; addr <= mhpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
         csr_wr_cb[addr] = &this_class::write_plain;
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index d3d0a09..bfcb31d 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -478,9 +478,10 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
     csr[mimpid] = 1;
 
     uart_buf.str("");
-    if(traits<BASE>::FLEN > 0)
+    if(traits<BASE>::FLEN > 0) {
         csr_rd_cb[fcsr] = &this_class::read_fcsr;
-    csr_wr_cb[fcsr] = &this_class::write_fcsr;
+        csr_wr_cb[fcsr] = &this_class::write_fcsr;
+    }
     for(unsigned addr = mhpmcounter3; addr <= mhpmcounter31; ++addr) {
         csr_rd_cb[addr] = &this_class::read_null;
         csr_wr_cb[addr] = &this_class::write_plain;

From 6ddb8da07ff815370b92550c1bd6752579bf41e5 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 2 Aug 2024 11:58:51 +0200
Subject: [PATCH 061/100] fixes missing rename

---
 src/iss/arch/hwl.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/iss/arch/hwl.h b/src/iss/arch/hwl.h
index 2da5f3a..6694a40 100644
--- a/src/iss/arch/hwl.h
+++ b/src/iss/arch/hwl.h
@@ -51,8 +51,8 @@ public:
     virtual ~hwl() = default;
 
 protected:
-    iss::status read_custom_csr_reg(unsigned addr, reg_t& val) override;
-    iss::status write_custom_csr_reg(unsigned addr, reg_t val) override;
+    iss::status read_custom_csr(unsigned addr, reg_t& val) override;
+    iss::status write_custom_csr(unsigned addr, reg_t val) override;
 };
 
 template <typename BASE>
@@ -68,7 +68,7 @@ inline hwl<BASE>::hwl(feature_config cfg)
     }
 }
 
-template <typename BASE> inline iss::status iss::arch::hwl<BASE>::read_custom_csr_reg(unsigned addr, reg_t& val) {
+template <typename BASE> inline iss::status iss::arch::hwl<BASE>::read_custom_csr(unsigned addr, reg_t& val) {
     switch(addr) {
     case 0x800:
         val = this->reg.lpstart0;
@@ -92,7 +92,7 @@ template <typename BASE> inline iss::status iss::arch::hwl<BASE>::read_custom_cs
     return iss::Ok;
 }
 
-template <typename BASE> inline iss::status iss::arch::hwl<BASE>::write_custom_csr_reg(unsigned addr, reg_t val) {
+template <typename BASE> inline iss::status iss::arch::hwl<BASE>::write_custom_csr(unsigned addr, reg_t val) {
     switch(addr) {
     case 0x800:
         this->reg.lpstart0 = val;

From 21f8eab432999fbadafb245a485abde285dd9195 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 2 Aug 2024 19:18:16 +0200
Subject: [PATCH 062/100] adds regenerated tgc5c

---
 src/iss/arch/tgc5c.cpp     | 2 +-
 src/iss/arch/tgc5c.h       | 2 +-
 src/vm/interp/vm_tgc5c.cpp | 3 ++-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/iss/arch/tgc5c.cpp b/src/iss/arch/tgc5c.cpp
index ae911d7..bdfbee3 100644
--- a/src/iss/arch/tgc5c.cpp
+++ b/src/iss/arch/tgc5c.cpp
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017 - 2020 MINRES Technologies GmbH
+ * Copyright (C) 2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/src/iss/arch/tgc5c.h b/src/iss/arch/tgc5c.h
index 606256a..a8819b8 100644
--- a/src/iss/arch/tgc5c.h
+++ b/src/iss/arch/tgc5c.h
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (C) 2017 - 2021 MINRES Technologies GmbH
+ * Copyright (C) 2024 MINRES Technologies GmbH
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 1c1d410..db5c0d4 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -96,7 +96,8 @@ protected:
     using compile_ret_t = virt_addr_t;
     using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr);
 
-    inline const char *name(size_t index){return index<traits::reg_aliases.size()?traits::reg_aliases[index]:"illegal";}
+    inline const char *name(size_t index){return traits::reg_aliases.at(index);}
+
 
     virt_addr_t execute_inst(finish_cond_e cond, virt_addr_t start, uint64_t icount_limit) override;
 

From 933f08494c50f13f317ac67d7373b20bd7136d2e Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sun, 4 Aug 2024 17:41:49 +0200
Subject: [PATCH 063/100] removes C++17 dependency from asmjit backend

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 6 +++---
 src/vm/asmjit/vm_tgc5c.cpp                  | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 245727b..87ab923 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -104,7 +104,7 @@ protected:
     void gen_instr_prologue(jit_holder& jh);
     void gen_instr_epilogue(jit_holder& jh);
     inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
-    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>> void gen_set_tval(jit_holder& jh, T new_tval) ;
+    template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type> void gen_set_tval(jit_holder& jh, T new_tval) ;
     void gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) ;
 
     template<unsigned W, typename U, typename S = typename std::make_signed<U>::type>
@@ -310,8 +310,8 @@ void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
     }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
-    if(std::holds_alternative<x86::Gp>(_new_tval)) {
-        x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
+    if(nonstd::holds_alternative<x86::Gp>(_new_tval)) {
+        x86::Gp new_tval = nonstd::get<x86::Gp>(_new_tval);
         if(new_tval.size() < 8)
             new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
         mov(jh.cc, jh.globals[TVAL], new_tval);
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 7f0729a..c99cc8a 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -104,7 +104,7 @@ protected:
     void gen_instr_prologue(jit_holder& jh);
     void gen_instr_epilogue(jit_holder& jh);
     inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
-    template <typename T, typename = std::enable_if_t<std::is_integral_v<T>>> void gen_set_tval(jit_holder& jh, T new_tval) ;
+    template <typename T, typename = typename std::enable_if<std::is_integral<T>::value>::type> void gen_set_tval(jit_holder& jh, T new_tval) ;
     void gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) ;
 
     template<unsigned W, typename U, typename S = typename std::make_signed<U>::type>
@@ -4850,8 +4850,8 @@ void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, T new_tval) {
     }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_set_tval(jit_holder& jh, x86_reg_t _new_tval) {
-    if(std::holds_alternative<x86::Gp>(_new_tval)) {
-        x86::Gp new_tval = std::get<x86::Gp>(_new_tval);
+    if(nonstd::holds_alternative<x86::Gp>(_new_tval)) {
+        x86::Gp new_tval = nonstd::get<x86::Gp>(_new_tval);
         if(new_tval.size() < 8)
             new_tval = gen_ext_Gp(jh.cc, new_tval, 64, false);
         mov(jh.cc, jh.globals[TVAL], new_tval);
@@ -4900,4 +4900,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
\ No newline at end of file
+// clang-format on

From b3cc9d234669666645dd3cdab467f7a230dbacf3 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sun, 4 Aug 2024 18:47:28 +0200
Subject: [PATCH 064/100] makes core_complex a template

---
 src/iss/arch/riscv_hart_m_p.h |  2 +-
 src/sysc/core_complex.cpp     | 63 ++++++++++++++++++++++++-----------
 src/sysc/core_complex.h       | 52 +++++++++++++++++++++--------
 src/sysc/sc_core_adapter.h    | 30 +++++------------
 src/vm/fp_functions.cpp       |  1 -
 5 files changed, 91 insertions(+), 57 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index f808891..bbd2b49 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -613,7 +613,7 @@ std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::str
                         CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
                 }
             }
-            for(const auto sec : reader.sections) {
+            for(const auto& sec : reader.sections) {
                 if(sec->get_name() == ".tohost") {
                     tohost = sec->get_address();
                     fromhost = tohost + 0x40;
diff --git a/src/sysc/core_complex.cpp b/src/sysc/core_complex.cpp
index 7b3e601..da8fd3f 100644
--- a/src/sysc/core_complex.cpp
+++ b/src/sysc/core_complex.cpp
@@ -199,7 +199,8 @@ struct core_trace {
 
 SC_HAS_PROCESS(core_complex); // NOLINT
 #ifndef CWR_SYSTEMC
-core_complex::core_complex(sc_module_name const& name)
+template <unsigned int BUSWIDTH>
+core_complex<BUSWIDTH>::core_complex(sc_module_name const& name)
 : sc_module(name)
 , fetch_lut(tlm_dmi_ext())
 , read_lut(tlm_dmi_ext())
@@ -208,7 +209,8 @@ core_complex::core_complex(sc_module_name const& name)
 }
 #endif
 
-void core_complex::init() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::init() {
     trc = new core_trace();
     ibus.register_invalidate_direct_mem_ptr([=](uint64_t start, uint64_t end) -> void {
         auto lut_entry = fetch_lut.getEntry(start);
@@ -227,6 +229,7 @@ void core_complex::init() {
         }
     });
 
+    SC_HAS_PROCESS(core_complex<BUSWIDTH>); // NOLINT
     SC_THREAD(run);
     SC_METHOD(rst_cb);
     sensitive << rst_i;
@@ -252,16 +255,19 @@ void core_complex::init() {
 #endif
 }
 
-core_complex::~core_complex() {
+template <unsigned int BUSWIDTH>
+core_complex<BUSWIDTH>::~core_complex() {
     delete cpu;
     delete trc;
     for(auto* p : plugin_list)
         delete p;
 }
 
-void core_complex::trace(sc_trace_file* trf) const {}
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::trace(sc_trace_file* trf) const {}
 
-void core_complex::before_end_of_elaboration() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::before_end_of_elaboration() {
     SCCDEBUG(SCMOD) << "instantiating iss::arch::tgf with " << GET_PROP_VALUE(backend) << " backend";
     // cpu = scc::make_unique<core_wrapper>(this);
     cpu = new core_wrapper(this);
@@ -302,7 +308,8 @@ void core_complex::before_end_of_elaboration() {
     }
 }
 
-void core_complex::start_of_simulation() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::start_of_simulation() {
     // quantum_keeper.reset();
     if(GET_PROP_VALUE(elf_file).size() > 0) {
         istringstream is(GET_PROP_VALUE(elf_file));
@@ -325,7 +332,8 @@ void core_complex::start_of_simulation() {
     }
 }
 
-bool core_complex::disass_output(uint64_t pc, const std::string instr_str) {
+template <unsigned int BUSWIDTH>
+bool core_complex<BUSWIDTH>::disass_output(uint64_t pc, const std::string instr_str) {
     if(trc->m_db == nullptr)
         return false;
     if(trc->tr_handle.is_active())
@@ -339,7 +347,8 @@ bool core_complex::disass_output(uint64_t pc, const std::string instr_str) {
     return true;
 }
 
-void core_complex::forward() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::forward() {
 #ifndef CWR_SYSTEMC
     set_clock_period(clk_i.read());
 #else
@@ -348,24 +357,30 @@ void core_complex::forward() {
 #endif
 }
 
-void core_complex::set_clock_period(sc_core::sc_time period) {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::set_clock_period(sc_core::sc_time period) {
     curr_clk = period;
     if(period == SC_ZERO_TIME)
         cpu->set_interrupt_execution(true);
 }
 
-void core_complex::rst_cb() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::rst_cb() {
     if(rst_i.read())
         cpu->set_interrupt_execution(true);
 }
 
-void core_complex::sw_irq_cb() { cpu->local_irq(3, sw_irq_i.read()); }
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::sw_irq_cb() { cpu->local_irq(3, sw_irq_i.read()); }
 
-void core_complex::timer_irq_cb() { cpu->local_irq(7, timer_irq_i.read()); }
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::timer_irq_cb() { cpu->local_irq(7, timer_irq_i.read()); }
 
-void core_complex::ext_irq_cb() { cpu->local_irq(11, ext_irq_i.read()); }
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::ext_irq_cb() { cpu->local_irq(11, ext_irq_i.read()); }
 
-void core_complex::local_irq_cb() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::local_irq_cb() {
     for(auto i = 0U; i < local_irq_i.size(); ++i) {
         if(local_irq_i[i].event()) {
             cpu->local_irq(16 + i, local_irq_i[i].read());
@@ -373,7 +388,8 @@ void core_complex::local_irq_cb() {
     }
 }
 
-void core_complex::run() {
+template <unsigned int BUSWIDTH>
+void core_complex<BUSWIDTH>::run() {
     wait(SC_ZERO_TIME); // separate from elaboration phase
     do {
         wait(SC_ZERO_TIME);
@@ -391,7 +407,8 @@ void core_complex::run() {
     sc_stop();
 }
 
-bool core_complex::read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) {
+template <unsigned int BUSWIDTH>
+bool core_complex<BUSWIDTH>::read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) {
     auto& dmi_lut = is_fetch ? fetch_lut : read_lut;
     auto lut_entry = dmi_lut.getEntry(addr);
     if(lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && addr + length <= lut_entry.get_end_address() + 1) {
@@ -449,7 +466,8 @@ bool core_complex::read_mem(uint64_t addr, unsigned length, uint8_t* const data,
     }
 }
 
-bool core_complex::write_mem(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <unsigned int BUSWIDTH>
+bool core_complex<BUSWIDTH>::write_mem(uint64_t addr, unsigned length, const uint8_t* const data) {
     auto lut_entry = write_lut.getEntry(addr);
     if(lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && addr + length <= lut_entry.get_end_address() + 1) {
         auto offset = addr - lut_entry.get_start_address();
@@ -497,7 +515,8 @@ bool core_complex::write_mem(uint64_t addr, unsigned length, const uint8_t* cons
     }
 }
 
-bool core_complex::read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) {
+template <unsigned int BUSWIDTH>
+bool core_complex<BUSWIDTH>::read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) {
     tlm::tlm_generic_payload gp;
     gp.set_command(tlm::TLM_READ_COMMAND);
     gp.set_address(addr);
@@ -507,7 +526,8 @@ bool core_complex::read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const d
     return dbus->transport_dbg(gp) == length;
 }
 
-bool core_complex::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <unsigned int BUSWIDTH>
+bool core_complex<BUSWIDTH>::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) {
     write_buf.resize(length);
     std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
     tlm::tlm_generic_payload gp;
@@ -518,5 +538,10 @@ bool core_complex::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t*
     gp.set_streaming_width(length);
     return dbus->transport_dbg(gp) == length;
 }
+
+template class core_complex<scc::LT>;
+template class core_complex<32>;
+template class core_complex<64>;
+
 } /* namespace tgfs */
 } /* namespace sysc */
diff --git a/src/sysc/core_complex.h b/src/sysc/core_complex.h
index 8d1c0c7..a31689a 100644
--- a/src/sysc/core_complex.h
+++ b/src/sysc/core_complex.h
@@ -36,6 +36,7 @@
 #include <scc/tick2time.h>
 #include <scc/traceable.h>
 #include <scc/utilities.h>
+#include <scc/signal_opt_ports.h>
 #include <tlm/scc/initiator_mixin.h>
 #include <tlm/scc/scv/tlm_rec_initiator_socket.h>
 #ifdef CWR_SYSTEMC
@@ -68,12 +69,35 @@ public:
 namespace tgfs {
 class core_wrapper;
 struct core_trace;
+struct core_complex_if {
 
-class core_complex : public sc_core::sc_module, public scc::traceable {
+    virtual ~core_complex_if() = default;
+
+    virtual bool read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) =0;
+
+    virtual bool write_mem(uint64_t addr, unsigned length, const uint8_t* const data)  =0;
+
+    virtual bool read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data)  =0;
+
+    virtual bool write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data)  =0;
+
+    virtual bool disass_output(uint64_t pc, const std::string instr)  =0;
+
+    virtual unsigned get_last_bus_cycles() =0;
+
+    virtual void sync(uint64_t) =0;
+
+    virtual char const* hier_name() = 0;
+
+    scc::sc_in_opt<uint64_t> mtime_i{"mtime_i"};
+};
+
+template <unsigned int BUSWIDTH = scc::LT>
+class core_complex : public sc_core::sc_module, public scc::traceable, public core_complex_if {
 public:
-    tlm::scc::initiator_mixin<tlm::tlm_initiator_socket<SOCKET_WIDTH>> ibus{"ibus"};
+    tlm::scc::initiator_mixin<tlm::tlm_initiator_socket<BUSWIDTH>> ibus{"ibus"};
 
-    tlm::scc::initiator_mixin<tlm::tlm_initiator_socket<SOCKET_WIDTH>> dbus{"dbus"};
+    tlm::scc::initiator_mixin<tlm::tlm_initiator_socket<BUSWIDTH>> dbus{"dbus"};
 
     sc_core::sc_in<bool> rst_i{"rst_i"};
 
@@ -88,8 +112,6 @@ public:
 #ifndef CWR_SYSTEMC
     sc_core::sc_in<sc_core::sc_time> clk_i{"clk_i"};
 
-    sc_core::sc_port<tlm::tlm_peek_if<uint64_t>, 1, sc_core::SC_ZERO_OR_MORE_BOUND> mtime_o{"mtime_o"};
-
     cci::cci_param<std::string> elf_file{"elf_file", ""};
 
     cci::cci_param<bool> enable_disass{"enable_disass", false};
@@ -115,8 +137,6 @@ public:
 #else
     sc_core::sc_in<bool> clk_i{"clk_i"};
 
-    sc_core::sc_in<uint64_t> mtime_i{"mtime_i"};
-
     scml_property<std::string> elf_file{"elf_file", ""};
 
     scml_property<bool> enable_disass{"enable_disass", false};
@@ -159,13 +179,13 @@ public:
 
     ~core_complex();
 
-    inline unsigned get_last_bus_cycles() {
+    unsigned get_last_bus_cycles() override {
         auto mem_incr = std::max(ibus_inc, dbus_inc);
         ibus_inc = dbus_inc = 0;
         return mem_incr > 1 ? mem_incr : 1;
     }
 
-    inline void sync(uint64_t cycle) {
+    void sync(uint64_t cycle) override {
         auto core_inc = curr_clk * (cycle - last_sync_cycle);
         quantum_keeper.inc(core_inc);
         if(quantum_keeper.need_sync()) {
@@ -175,20 +195,24 @@ public:
         last_sync_cycle = cycle;
     }
 
-    bool read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch);
+    bool read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) override;
 
-    bool write_mem(uint64_t addr, unsigned length, const uint8_t* const data);
+    bool write_mem(uint64_t addr, unsigned length, const uint8_t* const data) override;
 
-    bool read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data);
+    bool read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) override;
 
-    bool write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data);
+    bool write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) override;
 
     void trace(sc_core::sc_trace_file* trf) const override;
 
-    bool disass_output(uint64_t pc, const std::string instr);
+    bool disass_output(uint64_t pc, const std::string instr) override;
 
     void set_clock_period(sc_core::sc_time period);
 
+    char const* hier_name() override {
+        return name();
+    }
+
 protected:
     void before_end_of_elaboration() override;
     void start_of_simulation() override;
diff --git a/src/sysc/sc_core_adapter.h b/src/sysc/sc_core_adapter.h
index 10a1eb8..c140cac 100644
--- a/src/sysc/sc_core_adapter.h
+++ b/src/sysc/sc_core_adapter.h
@@ -21,7 +21,7 @@ public:
     using reg_t = typename iss::arch::traits<typename PLAT::core>::reg_t;
     using phys_addr_t = typename iss::arch::traits<typename PLAT::core>::phys_addr_t;
     using heart_state_t = typename PLAT::hart_state_type;
-    sc_core_adapter(sysc::tgfs::core_complex* owner)
+    sc_core_adapter(sysc::tgfs::core_complex_if* owner)
     : owner(owner) {}
 
     iss::arch_if* get_arch_if() override { return this; }
@@ -54,7 +54,7 @@ public:
             std::stringstream s;
             s << "[p:" << lvl[this->reg.PRIV] << ";s:0x" << std::hex << std::setfill('0') << std::setw(sizeof(reg_t) * 2)
               << (reg_t)this->state.mstatus << std::dec << ";c:" << this->reg.icount + this->cycle_offset << "]";
-            SCCDEBUG(owner->name()) << "disass: "
+            SCCDEBUG(owner->hier_name()) << "disass: "
                                     << "0x" << std::setw(16) << std::right << std::setfill('0') << std::hex << pc << "\t\t" << std::setw(40)
                                     << std::setfill(' ') << std::left << instr << s.str();
         }
@@ -79,10 +79,10 @@ public:
                     switch(hostvar >> 48) {
                     case 0:
                         if(hostvar != 0x1) {
-                            SCCINFO(owner->name())
+                            SCCINFO(owner->hier_name())
                                 << "tohost value is 0x" << std::hex << hostvar << std::dec << " (" << hostvar << "), stopping simulation";
                         } else {
-                            SCCINFO(owner->name())
+                            SCCINFO(owner->hier_name())
                                 << "tohost value is 0x" << std::hex << hostvar << std::dec << " (" << hostvar << "), stopping simulation";
                         }
                         this->reg.trap_state = std::numeric_limits<uint32_t>::max();
@@ -112,21 +112,8 @@ public:
     }
 
     iss::status read_csr(unsigned addr, reg_t& val) override {
-#ifndef CWR_SYSTEMC
-        if((addr == iss::arch::time || addr == iss::arch::timeh) && owner->mtime_o.get_interface(0)) {
-            uint64_t time_val;
-            bool ret = owner->mtime_o->nb_peek(time_val);
-            if(addr == iss::arch::time) {
-                val = static_cast<reg_t>(time_val);
-            } else if(addr == iss::arch::timeh) {
-                if(sizeof(reg_t) != 4)
-                    return iss::Err;
-                val = static_cast<reg_t>(time_val >> 32);
-            }
-            return ret ? iss::Ok : iss::Err;
-#else
         if((addr == iss::arch::time || addr == iss::arch::timeh)) {
-            uint64_t time_val = owner->mtime_i.read();
+            uint64_t time_val = owner->mtime_i.get_interface()? owner->mtime_i.read():0;
             if(addr == iss::arch::time) {
                 val = static_cast<reg_t>(time_val);
             } else if(addr == iss::arch::timeh) {
@@ -135,14 +122,13 @@ public:
                 val = static_cast<reg_t>(time_val >> 32);
             }
             return iss::Ok;
-#endif
         } else {
             return PLAT::read_csr(addr, val);
         }
     }
 
     void wait_until(uint64_t flags) override {
-        SCCDEBUG(owner->name()) << "Sleeping until interrupt";
+        SCCDEBUG(owner->hier_name()) << "Sleeping until interrupt";
         while(this->reg.pending_trap == 0 && (this->csr[iss::arch::mip] & this->csr[iss::arch::mie]) == 0) {
             sc_core::wait(wfi_evt);
         }
@@ -173,11 +159,11 @@ public:
             this->csr[iss::arch::mip] &= ~mask;
         this->check_interrupt();
         if(value)
-            SCCTRACE(owner->name()) << "Triggering interrupt " << id << " Pending trap: " << this->reg.pending_trap;
+            SCCTRACE(owner->hier_name()) << "Triggering interrupt " << id << " Pending trap: " << this->reg.pending_trap;
     }
 
 private:
-    sysc::tgfs::core_complex* const owner;
+    sysc::tgfs::core_complex_if* const owner;
     sc_core::sc_event wfi_evt;
     uint64_t hostvar{std::numeric_limits<uint64_t>::max()};
     unsigned to_host_wr_cnt = 0;
diff --git a/src/vm/fp_functions.cpp b/src/vm/fp_functions.cpp
index 865ee64..de824e5 100644
--- a/src/vm/fp_functions.cpp
+++ b/src/vm/fp_functions.cpp
@@ -128,7 +128,6 @@ uint32_t fcmp_s(uint32_t v1, uint32_t v2, uint32_t op) {
 }
 
 uint32_t fcvt_s(uint32_t v1, uint32_t op, uint8_t mode) {
-
     float32_t v1f{v1};
     softfloat_exceptionFlags = 0;
     float32_t r;

From c28e8fd00c9c58472cf9495737c20034e3390723 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sun, 4 Aug 2024 18:57:20 +0200
Subject: [PATCH 065/100] removes left-overs

---
 src/sysc/core_complex.h | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/sysc/core_complex.h b/src/sysc/core_complex.h
index a31689a..7f0bc08 100644
--- a/src/sysc/core_complex.h
+++ b/src/sysc/core_complex.h
@@ -41,10 +41,8 @@
 #include <tlm/scc/scv/tlm_rec_initiator_socket.h>
 #ifdef CWR_SYSTEMC
 #include <scmlinc/scml_property.h>
-#define SOCKET_WIDTH 32
 #else
 #include <cci_configuration>
-#define SOCKET_WIDTH scc::LT
 #endif
 #include <memory>
 #include <tlm>

From 2878dca6b577b706e780609a8a490d305c6b7483 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 6 Aug 2024 08:31:28 +0200
Subject: [PATCH 066/100] updates templates

---
 gen_input/templates/interp/CORENAME.cpp.gtl |  1 +
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 10 +++++++++-
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 8fcb64f..aaedc43 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -279,6 +279,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     <%}%>if(this->disass_enabled){
                         /* generate console output when executing the command */<%instr.disass.eachLine{%>
                         ${it}<%}%>
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers<%instr.usedVariables.each{ k,v->
                     if(v.isArray) {%>
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index e6250e4..9cdfbfe 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -85,7 +85,11 @@ protected:
     using compile_func = compile_ret_t (this_class::*)(virt_addr_t &pc, code_word_t instr, tu_builder&);
 
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
-
+<%
+def fcsr = registers.find {it.name=='FCSR'}
+if(fcsr != null) {%>
+    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}     
+<%}%>
     void setup_module(std::string m) override {
         super::setup_module(m);
     }
@@ -133,6 +137,9 @@ protected:
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
     }
 
+<%functions.each{ it.eachLine { %>
+    ${it}<%}%>
+<%}%>
 private:
     /****************************************************************************
      * start opcode definitions
@@ -163,6 +170,7 @@ private:
         <%}%>if(this->disass_enabled){
             /* generate console output when executing the command */<%instr.disass.eachLine{%>
             ${it}<%}%>
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ ${instr.length/8};

From 9c51d6eade29d90aeba63c505f127025cb758e18 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 7 Aug 2024 09:20:11 +0200
Subject: [PATCH 067/100] improves interp, only calls decode once per instr

---
 gen_input/templates/interp/CORENAME.cpp.gtl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index aaedc43..1c45797 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -267,7 +267,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
             uint32_t inst_index = instr_decoder.decode_instr(instr);
             opcode_e inst_id = arch::traits<ARCH>::opcode_e::MAX_OPCODE;;
             if(inst_index <instr_descr.size())
-                inst_id = instr_descr.at(instr_decoder.decode_instr(instr)).op;
+                inst_id = instr_descr[inst_index].op;
 
             // pre execution stuff
             this->core.reg.last_branch = 0;

From 62d21e11561a23ab8e899f98fbf4af2c5a9f9bf0 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 7 Aug 2024 09:21:07 +0200
Subject: [PATCH 068/100] updates disass

---
 src/vm/asmjit/vm_tgc5c.cpp | 78 +++++++++++++++++-----------------
 src/vm/interp/vm_tgc5c.cpp | 40 +++++++++++++-----
 src/vm/llvm/vm_tgc5c.cpp   | 76 ++++++++++++++++-----------------
 src/vm/tcc/vm_tgc5c.cpp    | 87 +++++++++++++++++++++++---------------
 4 files changed, 159 insertions(+), 122 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index c99cc8a..eb13809 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -2364,7 +2364,7 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "ecall";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -2401,7 +2401,7 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "ebreak";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -2438,7 +2438,7 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "mret";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -2475,7 +2475,7 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "wfi";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3388,7 +3388,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__addi4spn"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.addi4spn"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3436,7 +3436,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__lw"),
+                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.lw"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3482,7 +3482,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__sw"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.sw"),
                 fmt::arg("rs2", name(8+rs2)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3525,7 +3525,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__addi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.addi"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3572,8 +3572,8 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
-            std::string mnemonic = "c__nop";
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.nop";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
@@ -3609,7 +3609,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__jal"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.jal"),
                 fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3653,7 +3653,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__li"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.li"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3700,7 +3700,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__lui"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.lui"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3744,7 +3744,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c__addi16sp"),
+                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c.addi16sp"),
                 fmt::arg("nzimm", nzimm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3789,8 +3789,8 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
-            std::string mnemonic = "__reserved_clui";
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_clui";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
@@ -3828,7 +3828,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srli"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srli"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3869,7 +3869,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srai"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srai"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3923,7 +3923,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__andi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.andi"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -3965,7 +3965,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__sub"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.sub"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4007,7 +4007,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__xor"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.xor"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4048,7 +4048,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__or"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.or"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4089,7 +4089,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__and"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.and"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4129,7 +4129,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__j"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.j"),
                 fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4171,7 +4171,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__beqz"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.beqz"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4220,7 +4220,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__bnez"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.bnez"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4269,7 +4269,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c__slli"),
+                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c.slli"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("nzuimm", nzuimm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4317,7 +4317,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c__lwsp"),
+                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c.lwsp"),
                 fmt::arg("rd", name(rd)), fmt::arg("uimm", uimm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4367,7 +4367,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__mv"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.mv"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4413,7 +4413,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jr"),
                 fmt::arg("rs1", name(rs1)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4459,8 +4459,8 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
-            std::string mnemonic = "__reserved_cmv";
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_cmv";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
@@ -4498,7 +4498,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__add"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.add"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4546,7 +4546,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jalr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jalr"),
                 fmt::arg("rs1", name(rs1)));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4595,8 +4595,8 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
-            std::string mnemonic = "c__ebreak";
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.ebreak";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
             jh.disass_collection.push_back(mnemonic_ptr);
@@ -4634,7 +4634,7 @@ private:
             /* generate disass */
             
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c__swsp"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c.swsp"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("uimm", uimm));
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4679,7 +4679,7 @@ private:
         if(this->disass_enabled){
             /* generate disass */
             
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "dii";
             InvokeNode* call_print_disass;
             char* mnemonic_ptr = strdup(mnemonic.c_str());
@@ -4900,4 +4900,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
+// clang-format on
\ No newline at end of file
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index db5c0d4..7cd10ad 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -343,7 +343,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
             uint32_t inst_index = instr_decoder.decode_instr(instr);
             opcode_e inst_id = arch::traits<ARCH>::opcode_e::MAX_OPCODE;;
             if(inst_index <instr_descr.size())
-                inst_id = instr_descr.at(instr_decoder.decode_instr(instr)).op;
+                inst_id = instr_descr[inst_index].op;
 
             // pre execution stuff
             this->core.reg.last_branch = 0;
@@ -1458,7 +1458,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::ECALL: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "ecall");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "ecall";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 4;
@@ -1471,7 +1473,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::EBREAK: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "ebreak");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "ebreak";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 4;
@@ -1484,7 +1488,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::MRET: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "mret");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "mret";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 4;
@@ -1497,7 +1503,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::WFI: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "wfi");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "wfi";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 4;
@@ -1721,7 +1729,7 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
                         auto mnemonic = fmt::format(
-                            "{mnemonic:10} {rs1}, {rd}, {imm}", fmt::arg("mnemonic", "fence.i"),
+                            "{mnemonic:10} {rs1}, {rd}, {imm}", fmt::arg("mnemonic", "fence_i"),
                             fmt::arg("rs1", name(rs1)), fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
                         this->core.disass_output(pc.val, mnemonic);
                     }
@@ -2095,7 +2103,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     uint8_t nzimm = ((bit_sub<2,5>(instr)) | (bit_sub<12,1>(instr) << 5));
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "c.nop");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "c.nop";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2201,7 +2211,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                     uint8_t rd = ((bit_sub<7,5>(instr)));
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, ".reserved_clui");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = ".reserved_clui";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2520,7 +2532,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::__reserved_cmv: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, ".reserved_cmv");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = ".reserved_cmv";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2586,7 +2600,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::C__EBREAK: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "c.ebreak");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "c.ebreak";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
@@ -2625,7 +2641,9 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 case arch::traits<ARCH>::opcode_e::DII: {
                     if(this->disass_enabled){
                         /* generate console output when executing the command */
-                        this->core.disass_output(pc.val, "dii");
+                        //No disass specified, using instruction name
+                        std::string mnemonic = "dii";
+                        this->core.disass_output(pc.val, mnemonic);
                     }
                     // used registers// calculate next pc value
                     *NEXT_PC = *PC + 2;
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 6f098c0..7e2de93 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -2415,7 +2415,7 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "ecall";
             std::vector<Value*> args {
                 this->core_ptr,
@@ -2450,7 +2450,7 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "ebreak";
             std::vector<Value*> args {
                 this->core_ptr,
@@ -2485,7 +2485,7 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "mret";
             std::vector<Value*> args {
                 this->core_ptr,
@@ -2520,7 +2520,7 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "wfi";
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3502,7 +3502,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__addi4spn"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.addi4spn"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3552,7 +3552,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__lw"),
+                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.lw"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3602,7 +3602,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__sw"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.sw"),
                 fmt::arg("rs2", name(8+rs2)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3649,7 +3649,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__addi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.addi"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3698,8 +3698,8 @@ private:
         uint8_t nzimm = ((bit_sub<2,5>(instr)) | (bit_sub<12,1>(instr) << 5));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
-            std::string mnemonic = "c__nop";
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.nop";
             std::vector<Value*> args {
                 this->core_ptr,
                 this->gen_const(64, pc.val),
@@ -3733,7 +3733,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__jal"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.jal"),
                 fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3776,7 +3776,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__li"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.li"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3822,7 +3822,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__lui"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.lui"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3865,7 +3865,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c__addi16sp"),
+                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c.addi16sp"),
                 fmt::arg("nzimm", nzimm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3912,8 +3912,8 @@ private:
         uint8_t rd = ((bit_sub<7,5>(instr)));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
-            std::string mnemonic = "__reserved_clui";
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_clui";
             std::vector<Value*> args {
                 this->core_ptr,
                 this->gen_const(64, pc.val),
@@ -3949,7 +3949,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srli"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srli"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -3991,7 +3991,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srai"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srai"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4051,7 +4051,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__andi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.andi"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4095,7 +4095,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__sub"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.sub"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4139,7 +4139,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__xor"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.xor"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4181,7 +4181,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__or"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.or"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4223,7 +4223,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__and"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.and"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4264,7 +4264,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__j"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.j"),
                 fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4304,7 +4304,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__beqz"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.beqz"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4355,7 +4355,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__bnez"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.bnez"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4406,7 +4406,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c__slli"),
+                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c.slli"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("nzuimm", nzuimm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4455,7 +4455,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c__lwsp"),
+                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c.lwsp"),
                 fmt::arg("rd", name(rd)), fmt::arg("uimm", uimm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4509,7 +4509,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__mv"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.mv"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4554,7 +4554,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jr"),
                 fmt::arg("rs1", name(rs1)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4599,8 +4599,8 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
-            std::string mnemonic = "__reserved_cmv";
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_cmv";
             std::vector<Value*> args {
                 this->core_ptr,
                 this->gen_const(64, pc.val),
@@ -4636,7 +4636,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__add"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.add"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4686,7 +4686,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jalr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jalr"),
                 fmt::arg("rs1", name(rs1)));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4736,8 +4736,8 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
-            std::string mnemonic = "c__ebreak";
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.ebreak";
             std::vector<Value*> args {
                 this->core_ptr,
                 this->gen_const(64, pc.val),
@@ -4773,7 +4773,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c__swsp"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c.swsp"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("uimm", uimm));
             std::vector<Value*> args {
                 this->core_ptr,
@@ -4822,7 +4822,7 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            //This disass is not yet implemented
+            //No disass specified, using instruction name
             std::string mnemonic = "dii";
             std::vector<Value*> args {
                 this->core_ptr,
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 2aa5ab6..2c19cbe 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -133,6 +133,7 @@ protected:
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
     }
 
+
 private:
     /****************************************************************************
      * start opcode definitions
@@ -1881,7 +1882,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "ecall");
+            //No disass specified, using instruction name
+            std::string mnemonic = "ecall";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 4;
@@ -1905,7 +1908,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "ebreak");
+            //No disass specified, using instruction name
+            std::string mnemonic = "ebreak";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 4;
@@ -1929,7 +1934,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "mret");
+            //No disass specified, using instruction name
+            std::string mnemonic = "mret";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 4;
@@ -1953,7 +1960,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "wfi");
+            //No disass specified, using instruction name
+            std::string mnemonic = "wfi";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 4;
@@ -2646,7 +2655,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__addi4spn"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.addi4spn"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2683,7 +2692,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__lw"),
+                "{mnemonic:10} {rd}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.lw"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2716,7 +2725,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c__sw"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}({rs1})", fmt::arg("mnemonic", "c.sw"),
                 fmt::arg("rs2", name(8+rs2)), fmt::arg("uimm", uimm), fmt::arg("rs1", name(8+rs1)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2747,7 +2756,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__addi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.addi"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2783,7 +2792,9 @@ private:
         uint8_t nzimm = ((bit_sub<2,5>(instr)) | (bit_sub<12,1>(instr) << 5));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "c__nop");
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.nop";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 2;
@@ -2807,7 +2818,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__jal"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.jal"),
                 fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2840,7 +2851,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__li"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.li"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2876,7 +2887,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c__lui"),
+                "{mnemonic:10} {rd}, {imm:#05x}", fmt::arg("mnemonic", "c.lui"),
                 fmt::arg("rd", name(rd)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2909,7 +2920,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c__addi16sp"),
+                "{mnemonic:10} {nzimm:#05x}", fmt::arg("mnemonic", "c.addi16sp"),
                 fmt::arg("nzimm", nzimm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -2943,7 +2954,9 @@ private:
         uint8_t rd = ((bit_sub<7,5>(instr)));
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "__reserved_clui");
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_clui";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 2;
@@ -2969,7 +2982,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srli"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srli"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3000,7 +3013,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c__srai"),
+                "{mnemonic:10} {rs1}, {shamt}", fmt::arg("mnemonic", "c.srai"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("shamt", shamt));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3039,7 +3052,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__andi"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.andi"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3070,7 +3083,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__sub"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.sub"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3101,7 +3114,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__xor"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.xor"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3132,7 +3145,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__or"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.or"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3163,7 +3176,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__and"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.and"),
                 fmt::arg("rd", name(8+rd)), fmt::arg("rs2", name(8+rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3193,7 +3206,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c__j"),
+                "{mnemonic:10} {imm:#05x}", fmt::arg("mnemonic", "c.j"),
                 fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3224,7 +3237,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__beqz"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.beqz"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3259,7 +3272,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c__bnez"),
+                "{mnemonic:10} {rs1}, {imm:#05x}", fmt::arg("mnemonic", "c.bnez"),
                 fmt::arg("rs1", name(8+rs1)), fmt::arg("imm", imm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3294,7 +3307,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c__slli"),
+                "{mnemonic:10} {rs1}, {nzuimm}", fmt::arg("mnemonic", "c.slli"),
                 fmt::arg("rs1", name(rs1)), fmt::arg("nzuimm", nzuimm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3332,7 +3345,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c__lwsp"),
+                "{mnemonic:10} {rd}, sp, {uimm:#05x}", fmt::arg("mnemonic", "c.lwsp"),
                 fmt::arg("rd", name(rd)), fmt::arg("uimm", uimm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3369,7 +3382,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__mv"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.mv"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3404,7 +3417,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jr"),
                 fmt::arg("rs1", name(rs1)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3439,7 +3452,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "__reserved_cmv");
+            //No disass specified, using instruction name
+            std::string mnemonic = ".reserved_cmv";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 2;
@@ -3465,7 +3480,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c__add"),
+                "{mnemonic:10} {rd}, {rs2}", fmt::arg("mnemonic", "c.add"),
                 fmt::arg("rd", name(rd)), fmt::arg("rs2", name(rs2)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3502,7 +3517,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c__jalr"),
+                "{mnemonic:10} {rs1}", fmt::arg("mnemonic", "c.jalr"),
                 fmt::arg("rs1", name(rs1)));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3541,7 +3556,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "c__ebreak");
+            //No disass specified, using instruction name
+            std::string mnemonic = "c.ebreak";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 2;
@@ -3567,7 +3584,7 @@ private:
         if(this->disass_enabled){
             /* generate console output when executing the command */
             auto mnemonic = fmt::format(
-                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c__swsp"),
+                "{mnemonic:10} {rs2}, {uimm:#05x}(sp)", fmt::arg("mnemonic", "c.swsp"),
                 fmt::arg("rs2", name(rs2)), fmt::arg("uimm", uimm));
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
@@ -3600,7 +3617,9 @@ private:
         uint64_t PC = pc.val;
         if(this->disass_enabled){
             /* generate console output when executing the command */
-            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, "dii");
+            //No disass specified, using instruction name
+            std::string mnemonic = "dii";
+            tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, mnemonic);
         }
         auto cur_pc_val = tu.constant(pc.val, traits::reg_bit_widths[traits::PC]);
         pc=pc+ 2;

From 235a7e6e2410db354f63203bb98120a2201fc1f1 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 8 Aug 2024 11:08:28 +0200
Subject: [PATCH 069/100] updates template

---
 gen_input/templates/tcc/CORENAME.cpp.gtl |   2 +-
 src/vm/tcc/vm_tgc5c.cpp                  | 480 ++++++++++-------------
 2 files changed, 207 insertions(+), 275 deletions(-)

diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index 9cdfbfe..e01d400 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -195,7 +195,7 @@ private:
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
         }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
-        gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 2c19cbe..79b937e 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -351,8 +351,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)((int32_t)imm),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)((int32_t)imm),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -387,8 +386,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)(PC+(int32_t)imm),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+(int32_t)imm),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -429,8 +427,7 @@ private:
         	}
         	else{
         		if(rd!=0) {
-        		    tu.store(rd + traits::X0,
-        		          tu.constant((uint32_t)(PC+4),32));
+        		    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+4),32));
         		}
         		auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         		tu.store(traits::NEXT_PC, PC_val_v);
@@ -473,7 +470,7 @@ private:
         	auto addr_mask = (uint32_t)- 2;
         	auto new_pc = tu.assignment(tu.ext((tu.bitwise_and(
         	   (tu.add(
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant((int16_t)sext<12>(imm),16))),
         	   tu.constant(addr_mask,32))),32,false),32);
         	tu.open_if(tu.urem(
@@ -483,8 +480,7 @@ private:
         	this->gen_raise_trap(tu, 0, 0);
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)(PC+4),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+4),32));
         	}
         	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         	tu.store(traits::NEXT_PC, PC_val_v);
@@ -525,8 +521,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -572,8 +568,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -619,8 +615,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -666,8 +662,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)));
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -713,8 +709,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -760,8 +756,8 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)));
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)));
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -806,12 +802,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 8),8,true),8);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -847,12 +842,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 16),16,true),16);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -888,12 +882,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.ext(tu.read_mem(traits::MEM, load_address, 32),32,true),32);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -929,12 +922,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.read_mem(traits::MEM, load_address, 8),8);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -970,12 +962,11 @@ private:
         }
         else{
         	auto load_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
         	auto res = tu.assignment(tu.read_mem(traits::MEM, load_address, 16),16);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1011,9 +1002,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),8,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),8,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1048,9 +1039,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),16,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),16,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1085,9 +1076,9 @@ private:
         }
         else{
         	auto store_address = tu.assignment(tu.ext((tu.add(
-        	   tu.load(rs1+ traits::X0, 0),
+        	   tu.load(rs1 + traits::X0, 0),
         	   tu.constant((int16_t)sext<12>(imm),16))),32,false),32);
-        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2+ traits::X0, 0),32,false));
+        	tu.write_mem(traits::MEM, store_address, tu.ext(tu.load(rs2 + traits::X0, 0),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -1122,10 +1113,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((int16_t)sext<12>(imm),16))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((int16_t)sext<12>(imm),16))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1161,10 +1151,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_SLT,
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.constant((int16_t)sext<12>(imm),16))), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_SLT,
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.constant((int16_t)sext<12>(imm),16))), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1200,10 +1189,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_ULT,
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32))), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment((tu.icmp(ICmpInst::ICMP_ULT,
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32))), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1239,10 +1227,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_xor(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_xor(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1278,10 +1265,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_or(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_or(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1317,10 +1303,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_and(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
+        	    tu.store(rd + traits::X0, tu.bitwise_and(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((uint32_t)((int16_t)sext<12>(imm)),32)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1356,10 +1341,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(shamt,8)));
+        	    tu.store(rd + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(shamt,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1395,10 +1379,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.lshr(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(shamt,8)));
+        	    tu.store(rd + traits::X0, tu.lshr(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(shamt,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1434,10 +1417,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.constant(shamt,8))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.constant(shamt,8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1473,10 +1455,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1512,10 +1493,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.sub(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.sub(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1551,12 +1531,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
+        	    tu.store(rd + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1592,10 +1571,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_SLT,
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.ext(tu.load(rs2+ traits::X0, 0),32,true)), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_SLT,
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.ext(tu.load(rs2 + traits::X0, 0),32,true)), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1631,10 +1609,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_ULT,
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)), tu.constant(1,8),tu.constant(0,8)));
+        	    tu.store(rd + traits::X0, tu.conditionalAssignment(tu.icmp(ICmpInst::ICMP_ULT,
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)), tu.constant(1,8),tu.constant(0,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1670,10 +1647,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_xor(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_xor(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1709,12 +1685,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.lshr(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
+        	    tu.store(rd + traits::X0, tu.lshr(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64)))));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1750,12 +1725,11 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             (tu.bitwise_and(
-        	                tu.load(rs2+ traits::X0, 0),
-        	                tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64))))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       (tu.bitwise_and(
+        	          tu.load(rs2 + traits::X0, 0),
+        	          tu.constant((static_cast<uint32_t>(traits:: XLEN)-1),64))))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1791,10 +1765,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_or(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_or(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -1830,10 +1803,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.bitwise_and(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.bitwise_and(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2002,11 +1974,10 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rd!=0){ auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::CSR, csr, xrs1);
-        	tu.store(rd + traits::X0,
-        	      xrd);
+        	tu.store(rd + traits::X0, xrd);
         	}
         	else{
         		tu.write_mem(traits::CSR, csr, xrs1);
@@ -2045,15 +2016,14 @@ private:
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rs1!=0) {
         	    tu.write_mem(traits::CSR, csr, tu.bitwise_or(
         	       xrd,
         	       xrs1));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2089,15 +2059,14 @@ private:
         }
         else{
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
-        	auto xrs1 = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
+        	auto xrs1 = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
         	if(rs1!=0) {
         	    tu.write_mem(traits::CSR, csr, tu.bitwise_and(
         	       xrd,
         	       tu.logical_neg(xrs1)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2135,8 +2104,7 @@ private:
         	auto xrd = tu.assignment(tu.read_mem(traits::CSR, csr, 32),32);
         	tu.write_mem(traits::CSR, csr, tu.constant((uint32_t)zimm,32));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2178,8 +2146,7 @@ private:
         	       tu.constant((uint32_t)zimm,32)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2221,8 +2188,7 @@ private:
         	       tu.constant(~ ((uint32_t)zimm),32)));
         	}
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          xrd);
+        	    tu.store(rd + traits::X0, xrd);
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2287,11 +2253,10 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext(res,32,false));
+        	    tu.store(rd + traits::X0, tu.ext(res,32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2327,13 +2292,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.ext(tu.load(rs2+ traits::X0, 0),32,true)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2369,13 +2333,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	   tu.load(rs2+ traits::X0, 0)),64);
+        	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	   tu.load(rs2 + traits::X0, 0)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.ashr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.ashr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2411,13 +2374,12 @@ private:
         }
         else{
         	auto res = tu.assignment(tu.mul(
-        	   tu.load(rs1+ traits::X0, 0),
-        	   tu.load(rs2+ traits::X0, 0)),64);
+        	   tu.load(rs1 + traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0)),64);
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.lshr(
-        	             res,
-        	             tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.lshr(
+        	       res,
+        	       tu.constant(static_cast<uint32_t>(traits:: XLEN),32))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2452,30 +2414,27 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-        	auto dividend = tu.assignment(tu.ext(tu.load(rs1+ traits::X0, 0),32,true),32);
-        	auto divisor = tu.assignment(tu.ext(tu.load(rs2+ traits::X0, 0),32,true),32);
+        	auto dividend = tu.assignment(tu.ext(tu.load(rs1 + traits::X0, 0),32,true),32);
+        	auto divisor = tu.assignment(tu.ext(tu.load(rs2 + traits::X0, 0),32,true),32);
         	if(rd!=0){ tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   divisor,
         	   tu.constant(0,8)));
         	auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      divisor,
         	      tu.constant(- 1,8))));
-        	tu.store(rd + traits::X0,
-        	      tu.constant(MMIN,32));
+        	tu.store(rd + traits::X0, tu.constant(MMIN,32));
         	tu.open_else();
-        	tu.store(rd + traits::X0,
-        	      tu.ext((tu.sdiv(
-        	         dividend,
-        	         divisor)),32,false));
+        	tu.store(rd + traits::X0, tu.ext((tu.sdiv(
+        	   dividend,
+        	   divisor)),32,false));
         	tu.close_scope();
         	tu.open_else();
-        	tu.store(rd + traits::X0,
-        	      tu.constant((uint32_t)- 1,32));
+        	tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
         	tu.close_scope();
         	}
         }
@@ -2512,18 +2471,16 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.udiv(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.udiv(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)- 1,32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
         	}
         	tu.close_scope();
         }
@@ -2560,32 +2517,29 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.load(rs1+ traits::X0, 0),
+        	      tu.load(rs1 + traits::X0, 0),
         	      tu.constant(MMIN,32)),
         	   tu.icmp(ICmpInst::ICMP_EQ,
-        	      tu.ext(tu.load(rs2+ traits::X0, 0),32,true),
+        	      tu.ext(tu.load(rs2 + traits::X0, 0),32,true),
         	      tu.constant(- 1,8))));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant(0,8));
+        	    tu.store(rd + traits::X0, tu.constant(0,8));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.srem(
-        	             tu.ext(tu.load(rs1+ traits::X0, 0),32,true),
-        	             tu.ext(tu.load(rs2+ traits::X0, 0),32,true))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.srem(
+        	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
+        	       tu.ext(tu.load(rs2 + traits::X0, 0),32,true))),32,false));
         	}
         	tu.close_scope();
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs1+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
         	tu.close_scope();
         }
@@ -2622,18 +2576,16 @@ private:
         }
         else{
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-        	   tu.load(rs2+ traits::X0, 0),
+        	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.urem(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0)));
+        	    tu.store(rd + traits::X0, tu.urem(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0)));
         	}
         	tu.open_else();
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs1+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
         	tu.close_scope();
         }
@@ -2665,10 +2617,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         if(imm) {
-            tu.store(rd+8 + traits::X0,
-                  tu.ext((tu.add(
-                     tu.load(2+ traits::X0, 0),
-                     tu.constant(imm,16))),32,false));
+            tu.store(rd+8 + traits::X0, tu.ext((tu.add(
+               tu.load(2 + traits::X0, 0),
+               tu.constant(imm,16))),32,false));
         }
         else{
         	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2702,10 +2653,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
-        tu.store(rd+8 + traits::X0,
-              tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
+        tu.store(rd+8 + traits::X0, tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -2735,9 +2685,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         auto offs = tu.assignment(tu.ext((tu.add(
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(uimm,8))),32,false),32);
-        tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+8+ traits::X0, 0),32,false));
+        tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+8 + traits::X0, 0),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -2770,10 +2720,9 @@ private:
         }
         else{
         	if(rs1!=0) {
-        	    tu.store(rs1 + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant((int8_t)sext<6>(imm),8))),32,false));
+        	    tu.store(rs1 + traits::X0, tu.ext((tu.add(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant((int8_t)sext<6>(imm),8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2828,8 +2777,7 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
-        tu.store(1 + traits::X0,
-              tu.constant((uint32_t)(PC+2),32));
+        tu.store(1 + traits::X0, tu.constant((uint32_t)(PC+2),32));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<12>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
@@ -2865,8 +2813,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.constant((uint32_t)((int8_t)sext<6>(imm)),32));
+        	    tu.store(rd + traits::X0, tu.constant((uint32_t)((int8_t)sext<6>(imm)),32));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2900,8 +2847,7 @@ private:
             this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         if(rd!=0) {
-            tu.store(rd + traits::X0,
-                  tu.constant((uint32_t)((int32_t)sext<18>(imm)),32));
+            tu.store(rd + traits::X0, tu.constant((uint32_t)((int32_t)sext<18>(imm)),32));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -2930,10 +2876,9 @@ private:
         tu.open_scope();
         this->gen_set_tval(tu, instr);
         if(nzimm) {
-            tu.store(2 + traits::X0,
-                  tu.ext((tu.add(
-                     tu.load(2+ traits::X0, 0),
-                     tu.constant((int16_t)sext<10>(nzimm),16))),32,false));
+            tu.store(2 + traits::X0, tu.ext((tu.add(
+               tu.load(2 + traits::X0, 0),
+               tu.constant((int16_t)sext<10>(nzimm),16))),32,false));
         }
         else{
         	this->gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -2991,10 +2936,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rs1+8 + traits::X0,
-              tu.lshr(
-                 tu.load(rs1+8+ traits::X0, 0),
-                 tu.constant(shamt,8)));
+        tu.store(rs1+8 + traits::X0, tu.lshr(
+           tu.load(rs1+8 + traits::X0, 0),
+           tu.constant(shamt,8)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3022,16 +2966,14 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        if(shamt){ tu.store(rs1+8 + traits::X0,
-              tu.ext((tu.ashr(
-                 (tu.ext(tu.load(rs1+8+ traits::X0, 0),32,true)),
-                 tu.constant(shamt,8))),32,false));
+        if(shamt){ tu.store(rs1+8 + traits::X0, tu.ext((tu.ashr(
+           (tu.ext(tu.load(rs1+8 + traits::X0, 0),32,true)),
+           tu.constant(shamt,8))),32,false));
         }
         else{
-        	if(static_cast<uint32_t>(traits:: XLEN)==128){ tu.store(rs1+8 + traits::X0,
-        	      tu.ext((tu.ashr(
-        	         (tu.ext(tu.load(rs1+8+ traits::X0, 0),32,true)),
-        	         tu.constant(64,8))),32,false));
+        	if(static_cast<uint32_t>(traits:: XLEN)==128){ tu.store(rs1+8 + traits::X0, tu.ext((tu.ashr(
+        	   (tu.ext(tu.load(rs1+8 + traits::X0, 0),32,true)),
+        	   tu.constant(64,8))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3061,10 +3003,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rs1+8 + traits::X0,
-              tu.ext((tu.bitwise_and(
-                 tu.load(rs1+8+ traits::X0, 0),
-                 tu.constant((int8_t)sext<6>(imm),8))),32,false));
+        tu.store(rs1+8 + traits::X0, tu.ext((tu.bitwise_and(
+           tu.load(rs1+8 + traits::X0, 0),
+           tu.constant((int8_t)sext<6>(imm),8))),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3092,10 +3033,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.ext((tu.sub(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0))),32,false));
+        tu.store(rd+8 + traits::X0, tu.ext((tu.sub(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0))),32,false));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3123,10 +3063,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_xor(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_xor(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3154,10 +3093,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_or(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_or(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3185,10 +3123,9 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        tu.store(rd+8 + traits::X0,
-              tu.bitwise_and(
-                 tu.load(rd+8+ traits::X0, 0),
-                 tu.load(rs2+8+ traits::X0, 0)));
+        tu.store(rd+8 + traits::X0, tu.bitwise_and(
+           tu.load(rd+8 + traits::X0, 0),
+           tu.load(rs2+8 + traits::X0, 0)));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3248,7 +3185,7 @@ private:
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
@@ -3283,7 +3220,7 @@ private:
         this->gen_set_tval(tu, instr);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
-           tu.load(rs1+8+ traits::X0, 0),
+           tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
@@ -3321,10 +3258,9 @@ private:
         }
         else{
         	if(rs1!=0) {
-        	    tu.store(rs1 + traits::X0,
-        	          tu.shl(
-        	             tu.load(rs1+ traits::X0, 0),
-        	             tu.constant(nzuimm,8)));
+        	    tu.store(rs1 + traits::X0, tu.shl(
+        	       tu.load(rs1 + traits::X0, 0),
+        	       tu.constant(nzuimm,8)));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3359,10 +3295,9 @@ private:
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
-        	   tu.load(2+ traits::X0, 0),
+        	   tu.load(2 + traits::X0, 0),
         	   tu.constant(uimm,8))),32,false),32);
-        	tu.store(rd + traits::X0,
-        	      tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
+        	tu.store(rd + traits::X0, tu.ext(tu.ext(tu.read_mem(traits::MEM, offs, 32),32,true),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -3396,8 +3331,7 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.load(rs2+ traits::X0, 0));
+        	    tu.store(rd + traits::X0, tu.load(rs2 + traits::X0, 0));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3429,7 +3363,7 @@ private:
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(NO_JUMP),32));
         if(rs1&&rs1<static_cast<uint32_t>(traits:: RFS)){ auto addr_mask = (uint32_t)- 2;
         auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
-           tu.load(rs1%static_cast<uint32_t>(traits:: RFS)+ traits::X0, 0),
+           tu.load(rs1%static_cast<uint32_t>(traits:: RFS) + traits::X0, 0),
            tu.constant(addr_mask,32)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
@@ -3494,10 +3428,9 @@ private:
         }
         else{
         	if(rd!=0) {
-        	    tu.store(rd + traits::X0,
-        	          tu.ext((tu.add(
-        	             tu.load(rd+ traits::X0, 0),
-        	             tu.load(rs2+ traits::X0, 0))),32,false));
+        	    tu.store(rd + traits::X0, tu.ext((tu.add(
+        	       tu.load(rd + traits::X0, 0),
+        	       tu.load(rs2 + traits::X0, 0))),32,false));
         	}
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3532,9 +3465,8 @@ private:
         }
         else{
         	auto addr_mask = (uint32_t)- 2;
-        	auto new_pc = tu.assignment(tu.load(rs1+ traits::X0, 0),32);
-        	tu.store(1 + traits::X0,
-        	      tu.constant((uint32_t)(PC+2),32));
+        	auto new_pc = tu.assignment(tu.load(rs1 + traits::X0, 0),32);
+        	tu.store(1 + traits::X0, tu.constant((uint32_t)(PC+2),32));
         	auto PC_val_v = tu.assignment("PC_val", tu.bitwise_and(
         	   new_pc,
         	   tu.constant(addr_mask,32)),32);
@@ -3598,9 +3530,9 @@ private:
         }
         else{
         	auto offs = tu.assignment(tu.ext((tu.add(
-        	   tu.load(2+ traits::X0, 0),
+        	   tu.load(2 + traits::X0, 0),
         	   tu.constant(uimm,8))),32,false),32);
-        	tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2+ traits::X0, 0),32,false));
+        	tu.write_mem(traits::MEM, offs, tu.ext(tu.load(rs2 + traits::X0, 0),32,false));
         }
         auto returnValue = std::make_tuple(CONT);
         
@@ -3645,7 +3577,7 @@ private:
             tu("print_disass(core_ptr, {:#x}, \"{}\");", pc.val, std::string("illegal_instruction"));
         }
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
-        gen_raise_trap(tu, 0, 2);     // illegal instruction trap
+        gen_raise_trap(tu, 0, static_cast<int32_t>(traits:: RV_CAUSE_ILLEGAL_INSTRUCTION));
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);

From fbca690b3b48e9fdaf4cce8e0793b65529ca69de Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Thu, 8 Aug 2024 12:57:08 +0200
Subject: [PATCH 070/100] replaces gen_wait, updates template to include
 fp_functions when necessary

---
 gen_input/templates/tcc/CORENAME.cpp.gtl | 41 ++++++++++++++++++++----
 src/vm/tcc/vm_tgc5c.cpp                  |  8 ++---
 2 files changed, 37 insertions(+), 12 deletions(-)

diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index e01d400..c215a03 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -88,7 +88,9 @@ protected:
 <%
 def fcsr = registers.find {it.name=='FCSR'}
 if(fcsr != null) {%>
-    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}     
+    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}   
+
+    void add_prologue(tu_builder& tu) override;
 <%}%>
     void setup_module(std::string m) override {
         super::setup_module(m);
@@ -102,8 +104,6 @@ if(fcsr != null) {%>
 
     void gen_leave_trap(tu_builder& tu, unsigned lvl);
 
-    void gen_wait(tu_builder& tu, unsigned type);
-
     inline void gen_set_tval(tu_builder& tu, uint64_t new_tval);
 
     inline void gen_set_tval(tu_builder& tu, value new_tval);
@@ -266,9 +266,6 @@ template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsi
     tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 32));
 }
 
-template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
-}
-
 template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, uint64_t new_tval) {
     tu(fmt::format("tval = {};", new_tval));
 }
@@ -283,6 +280,38 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP),32));
     tu("return *next_pc;");
 }
+<%
+if(fcsr != null) {%>
+template <typename ARCH> void vm_impl<ARCH>::add_prologue(tu_builder& tu){
+    std::ostringstream os;
+    os << "uint32_t (*fadd_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fadd_s << ";\\n";
+    os << "uint32_t (*fsub_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fsub_s << ";\\n";
+    os << "uint32_t (*fmul_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fmul_s << ";\\n";
+    os << "uint32_t (*fdiv_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fdiv_s << ";\\n";
+    os << "uint32_t (*fsqrt_s)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&fsqrt_s << ";\\n";
+    os << "uint32_t (*fcmp_s)(uint32_t v1, uint32_t v2, uint32_t op)=" << (uintptr_t)&fcmp_s << ";\\n";
+    os << "uint32_t (*fcvt_s)(uint32_t v1, uint32_t op, uint8_t mode)=" << (uintptr_t)&fcvt_s << ";\\n";
+    os << "uint32_t (*fmadd_s)(uint32_t v1, uint32_t v2, uint32_t v3, uint32_t op, uint8_t mode)=" << (uintptr_t)&fmadd_s << ";\\n";
+    os << "uint32_t (*fsel_s)(uint32_t v1, uint32_t v2, uint32_t op)=" << (uintptr_t)&fsel_s << ";\\n";
+    os << "uint32_t (*fclass_s)( uint32_t v1 )=" << (uintptr_t)&fclass_s << ";\\n";
+    os << "uint32_t (*fconv_d2f)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&fconv_d2f << ";\\n";
+    os << "uint64_t (*fconv_f2d)(uint32_t v1, uint8_t mode)=" << (uintptr_t)&fconv_f2d << ";\\n";
+    os << "uint64_t (*fadd_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fadd_d << ";\\n";
+    os << "uint64_t (*fsub_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fsub_d << ";\\n";
+    os << "uint64_t (*fmul_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fmul_d << ";\\n";
+    os << "uint64_t (*fdiv_d)(uint64_t v1, uint64_t v2, uint8_t mode)=" << (uintptr_t)&fdiv_d << ";\\n";
+    os << "uint64_t (*fsqrt_d)(uint64_t v1, uint8_t mode)=" << (uintptr_t)&fsqrt_d << ";\\n";
+    os << "uint64_t (*fcmp_d)(uint64_t v1, uint64_t v2, uint32_t op)=" << (uintptr_t)&fcmp_d << ";\\n";
+    os << "uint64_t (*fcvt_d)(uint64_t v1, uint32_t op, uint8_t mode)=" << (uintptr_t)&fcvt_d << ";\\n";
+    os << "uint64_t (*fmadd_d)(uint64_t v1, uint64_t v2, uint64_t v3, uint32_t op, uint8_t mode)=" << (uintptr_t)&fmadd_d << ";\\n";
+    os << "uint64_t (*fsel_d)(uint64_t v1, uint64_t v2, uint32_t op)=" << (uintptr_t)&fsel_d << ";\\n";
+    os << "uint64_t (*fclass_d)(uint64_t v1  )=" << (uintptr_t)&fclass_d << ";\\n";
+    os << "uint64_t (*fcvt_32_64)(uint32_t v1, uint32_t op, uint8_t mode)=" << (uintptr_t)&fcvt_32_64 << ";\\n";
+    os << "uint32_t (*fcvt_64_32)(uint64_t v1, uint32_t op, uint8_t mode)=" << (uintptr_t)&fcvt_64_32 << ";\\n";
+    os << "uint32_t (*unbox_s)(uint64_t v)=" << (uintptr_t)&unbox_s << ";\\n";
+    tu.add_prologue(os.str());
+}
+<%}%>
 
 } // namespace ${coreDef.name.toLowerCase()}
 
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 79b937e..23daf58 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -98,8 +98,6 @@ protected:
 
     void gen_leave_trap(tu_builder& tu, unsigned lvl);
 
-    void gen_wait(tu_builder& tu, unsigned type);
-
     inline void gen_set_tval(tu_builder& tu, uint64_t new_tval);
 
     inline void gen_set_tval(tu_builder& tu, value new_tval);
@@ -1941,7 +1939,7 @@ private:
         gen_set_pc(tu, pc, traits::NEXT_PC);
         tu.open_scope();
         this->gen_set_tval(tu, instr);
-        this->gen_wait(tu, 1);
+        tu.callf("wait", tu.constant(1,8));
         auto returnValue = std::make_tuple(CONT);
         
         tu.close_scope();
@@ -3648,9 +3646,6 @@ template <typename ARCH> void vm_impl<ARCH>::gen_leave_trap(tu_builder& tu, unsi
     tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 32));
 }
 
-template <typename ARCH> void vm_impl<ARCH>::gen_wait(tu_builder& tu, unsigned type) {
-}
-
 template <typename ARCH> void vm_impl<ARCH>::gen_set_tval(tu_builder& tu, uint64_t new_tval) {
     tu(fmt::format("tval = {};", new_tval));
 }
@@ -3666,6 +3661,7 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
     tu("return *next_pc;");
 }
 
+
 } // namespace tgc5c
 
 template <>

From 0b5062d21cb2347fe2d9da31849808d0ef3c9485 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Fri, 9 Aug 2024 11:56:32 +0200
Subject: [PATCH 071/100] adds fp_functions here to remove dependencies in
 dbt-rise-core

---
 gen_input/templates/tcc/CORENAME.cpp.gtl | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index c215a03..ec327a1 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -38,7 +38,9 @@
 #include <util/logging.h>
 #include <sstream>
 #include <iss/instruction_decoder.h>
-
+<%def fcsr = registers.find {it.name=='FCSR'}
+if(fcsr != null) {%>
+#include <vm/fp_functions.h><%}%>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
@@ -86,7 +88,6 @@ protected:
 
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
 <%
-def fcsr = registers.find {it.name=='FCSR'}
 if(fcsr != null) {%>
     inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}   
 
@@ -284,6 +285,7 @@ template <typename ARCH> void vm_impl<ARCH>::gen_trap_behavior(tu_builder& tu) {
 if(fcsr != null) {%>
 template <typename ARCH> void vm_impl<ARCH>::add_prologue(tu_builder& tu){
     std::ostringstream os;
+    os << "uint32_t (*fget_flags)()=" << (uintptr_t)&fget_flags << ";\\n";
     os << "uint32_t (*fadd_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fadd_s << ";\\n";
     os << "uint32_t (*fsub_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fsub_s << ";\\n";
     os << "uint32_t (*fmul_s)(uint32_t v1, uint32_t v2, uint8_t mode)=" << (uintptr_t)&fmul_s << ";\\n";

From b5341700aa1101ce4aedd80ac1a68b6ee65b83c7 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 13 Aug 2024 08:55:14 +0200
Subject: [PATCH 072/100] updates template and adds braces when using
 conditions

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 13 ++++++--
 src/vm/asmjit/vm_tgc5c.cpp                  | 33 ++++++++++++++++++++-
 2 files changed, 42 insertions(+), 4 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 87ab923..ad21cb8 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -38,7 +38,9 @@
 #include <asmjit/asmjit.h>
 #include <util/logging.h>
 #include <iss/instruction_decoder.h>
-
+<%def fcsr = registers.find {it.name=='FCSR'}
+if(fcsr != null) {%>
+#include <vm/fp_functions.h><%}%>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
@@ -100,7 +102,9 @@ protected:
     void gen_block_prologue(jit_holder& jh) override;
     void gen_block_epilogue(jit_holder& jh) override;
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
-
+<%if(fcsr != null) {%>
+    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}   
+<%}%>
     void gen_instr_prologue(jit_holder& jh);
     void gen_instr_epilogue(jit_holder& jh);
     inline void gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t cause);
@@ -112,7 +116,10 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    } 
+    }
+<%functions.each{ it.eachLine { %>
+    ${it}<%}%>
+<%}%>
 private:
     /****************************************************************************
      * start opcode definitions
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index eb13809..7f394d8 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -112,7 +112,8 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    } 
+    }
+
 private:
     /****************************************************************************
      * start opcode definitions
@@ -500,6 +501,7 @@ private:
                 (gen_operation(cc, band, (gen_operation(cc, add, load_reg_from_mem(jh, traits::X0 + rs1), (int16_t)sext<12>(imm))
                 ), addr_mask)
                 ), 32, true);
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, urem, new_pc, static_cast<uint32_t>(traits::INSTR_ALIGNMENT))
             ,0);
@@ -521,6 +523,7 @@ private:
                     mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(UNKNOWN_JUMP));
                 }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -566,6 +569,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
@@ -583,6 +587,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -628,6 +633,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
@@ -645,6 +651,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -690,6 +697,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, lt, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(cc, 
@@ -709,6 +717,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -754,6 +763,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, gte, gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs1), 32, false), gen_ext(cc, 
@@ -773,6 +783,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -818,6 +829,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, ltu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
@@ -835,6 +847,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -880,6 +893,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, gteu, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2))
             ,0);
@@ -897,6 +911,7 @@ private:
                 }
             }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = BRANCH;
         
@@ -3116,6 +3131,7 @@ private:
             auto divisor = gen_ext(cc, 
                 load_reg_from_mem(jh, traits::X0 + rs2), 32, true);
             if(rd!=0){
+                {
                 auto label_merge = cc.newLabel();
                 cmp(cc, gen_operation(cc, ne, divisor, 0)
                 ,0);
@@ -3123,6 +3139,7 @@ private:
                 cc.je(label_else);
                 {
                     auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
+                    {
                     auto label_merge = cc.newLabel();
                     cmp(cc, gen_operation(cc, land, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
                     , gen_operation(cc, eq, divisor, - 1)
@@ -3143,6 +3160,7 @@ private:
                                       ), 32, true));
                         }
                     cc.bind(label_merge);
+                    }
                 }
                 cc.jmp(label_merge);
                 cc.bind(label_else);
@@ -3151,6 +3169,7 @@ private:
                               (uint32_t)- 1);
                     }
                 cc.bind(label_merge);
+                }
             }
         }
         auto returnValue = CONT;
@@ -3196,6 +3215,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
@@ -3217,6 +3237,7 @@ private:
                     }
                 }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = CONT;
         
@@ -3261,6 +3282,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
@@ -3268,6 +3290,7 @@ private:
             cc.je(label_else);
             {
                 auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
+                {
                 auto label_merge = cc.newLabel();
                 cmp(cc, gen_operation(cc, land, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1), MMIN)
                 , gen_operation(cc, eq, gen_ext(cc, 
@@ -3296,6 +3319,7 @@ private:
                         }
                     }
                 cc.bind(label_merge);
+                }
             }
             cc.jmp(label_merge);
             cc.bind(label_else);
@@ -3306,6 +3330,7 @@ private:
                     }
                 }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = CONT;
         
@@ -3350,6 +3375,7 @@ private:
             gen_raise(jh, 0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto label_merge = cc.newLabel();
             cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs2), 0)
             ,0);
@@ -3371,6 +3397,7 @@ private:
                     }
                 }
             cc.bind(label_merge);
+            }
         }
         auto returnValue = CONT;
         
@@ -4194,6 +4221,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
+        {
         auto label_merge = cc.newLabel();
         cmp(cc, gen_operation(cc, eq, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
@@ -4204,6 +4232,7 @@ private:
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         }
         cc.bind(label_merge);
+        }
         auto returnValue = BRANCH;
         
         gen_sync(jh, POST_SYNC, 75);
@@ -4243,6 +4272,7 @@ private:
         cc.comment("//behavior:");
         /*generate behavior*/
         mov(jh.cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(NO_JUMP));
+        {
         auto label_merge = cc.newLabel();
         cmp(cc, gen_operation(cc, ne, load_reg_from_mem(jh, traits::X0 + rs1+8), 0)
         ,0);
@@ -4253,6 +4283,7 @@ private:
             mov(cc, get_ptr_for(jh, traits::LAST_BRANCH), static_cast<int>(KNOWN_JUMP));
         }
         cc.bind(label_merge);
+        }
         auto returnValue = BRANCH;
         
         gen_sync(jh, POST_SYNC, 76);

From 6609d12582d2bdd9fc777217a2296bacf7678d81 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 13 Aug 2024 15:22:34 +0200
Subject: [PATCH 073/100] adds flimit that gets properly evaluated in interp

---
 src/main.cpp | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 940a106..02ae4b0 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -69,7 +69,8 @@ int main(int argc, char* argv[]) {
         ("logfile,l", po::value<std::string>(), "Sets default log file.")
         ("disass,d", po::value<std::string>()->implicit_value(""), "Enables disassembly")
         ("gdb-port,g", po::value<unsigned>()->default_value(0), "enable gdb server and specify port to use")
-        ("instructions,i", po::value<uint64_t>()->default_value(std::numeric_limits<uint64_t>::max()), "max. number of instructions to simulate")
+        ("ilimit,i", po::value<uint64_t>()->default_value(std::numeric_limits<uint64_t>::max()), "max. number of instructions to simulate")
+        ("flimit", po::value<uint64_t>()->default_value(std::numeric_limits<uint64_t>::max()), "max. number of fetches to simulate")
         ("reset,r", po::value<std::string>(), "reset address")
         ("dump-ir", "dump the intermediate representation")
         ("elf,f", po::value<std::vector<std::string>>(), "ELF file(s) to load")
@@ -215,8 +216,15 @@ int main(int argc, char* argv[]) {
             start_address = str.find("0x") == 0 ? std::stoull(str.substr(2), nullptr, 16) : std::stoull(str, nullptr, 10);
         }
         vm->reset(start_address);
-        auto cycles = clim["instructions"].as<uint64_t>();
-        res = vm->start(cycles, dump);
+        auto limit = clim["ilimit"].as<uint64_t>();
+        auto cond = iss::finish_cond_e::JUMP_TO_SELF;
+        if(clim.count("flimit")) {
+            cond = cond | iss::finish_cond_e::FCOUNT_LIMIT;
+            limit = clim["flimit"].as<uint64_t>();
+        } else {
+            cond = cond | iss::finish_cond_e::ICOUNT_LIMIT;
+        }
+        res = vm->start(limit, dump, cond);
 
         auto instr_if = vm->get_arch()->get_instrumentation_if();
         // this assumes a single input file

From c15cdb095580fe80197aab9311bda6c558c8afb0 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 14 Aug 2024 11:49:59 +0200
Subject: [PATCH 074/100] expands return values of jit creating functions to
 inhibit endless trapping

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl |  6 +++---
 gen_input/templates/llvm/CORENAME.cpp.gtl   | 18 +++++-------------
 gen_input/templates/tcc/CORENAME.cpp.gtl    | 18 +++++-------------
 src/vm/asmjit/vm_tgc5c.cpp                  |  6 +++---
 src/vm/llvm/vm_tgc5c.cpp                    | 18 +++++-------------
 src/vm/tcc/vm_tgc5c.cpp                     | 18 +++++-------------
 6 files changed, 26 insertions(+), 58 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index ad21cb8..47b07ca 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -202,7 +202,7 @@ private:
         gen_raise(jh, 0, 2);
         gen_sync(jh, POST_SYNC, instr_descr.size());
         gen_instr_epilogue(jh);
-        return BRANCH;
+        return ILLEGAL_INSTR;
     }
 };
 
@@ -231,9 +231,9 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
         paddr = this->core.virt2phys(pc);
     auto res = this->core.read(paddr, 4, data);
     if (res != iss::Ok)
-        throw trap_access(TRAP_ID, pc.val);
+        return ILLEGAL_FETCH;
     if (instr == 0x0000006f || (instr&0xffff)==0xa001)
-        throw simulation_stopped(0); // 'J 0' or 'C.J 0'
+        return JUMP_TO_SELF;
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index a98b832..9c90f61 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -212,7 +212,7 @@ private:
         bb = this->leave_blk;
         this->gen_instr_epilogue(bb);
         this->builder.CreateBr(bb);
-        return std::make_tuple(BRANCH, nullptr);
+        return std::make_tuple(ILLEGAL_INSTR, nullptr);
     }    
 };
 
@@ -247,19 +247,11 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     auto *const data = (uint8_t *)&instr;
     if(this->core.has_mmu())
         paddr = this->core.virt2phys(pc);
-    //TODO: re-add page handling
-//    if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
-//        auto res = this->core.read(paddr, 2, data);
-//        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//        if ((instr & 0x3) == 0x3) { // this is a 32bit instruction
-//            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
-//        }
-//    } else {
     auto res = this->core.read(paddr, 4, data);
-    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//    }
-    if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-    // curr pc on stack
+    if (res != iss::Ok) 
+        return std::make_tuple(ILLEGAL_FETCH, nullptr);
+    if (instr == 0x0000006f || (instr&0xffff)==0xa001)
+        return std::make_tuple(JUMP_TO_SELF, nullptr);
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;
diff --git a/gen_input/templates/tcc/CORENAME.cpp.gtl b/gen_input/templates/tcc/CORENAME.cpp.gtl
index ec327a1..06317b0 100644
--- a/gen_input/templates/tcc/CORENAME.cpp.gtl
+++ b/gen_input/templates/tcc/CORENAME.cpp.gtl
@@ -200,7 +200,7 @@ private:
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
-        return BRANCH;
+        return ILLEGAL_INSTR;
     }
 };
 
@@ -233,19 +233,11 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     phys_addr_t paddr(pc);
     if(this->core.has_mmu())
         paddr = this->core.virt2phys(pc);
-    //TODO: re-add page handling
-//    if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
-//        auto res = this->core.read(paddr, 2, data);
-//        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//        if ((insn & 0x3) == 0x3) { // this is a 32bit instruction
-//            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
-//        }
-//    } else {
     auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
-    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//    }
-    if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-    // curr pc on stack
+    if (res != iss::Ok)
+        return ILLEGAL_FETCH;
+    if (instr == 0x0000006f || (instr&0xffff)==0xa001) 
+        return JUMP_TO_SELF;
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 7f394d8..deb5004 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4766,7 +4766,7 @@ private:
         gen_raise(jh, 0, 2);
         gen_sync(jh, POST_SYNC, instr_descr.size());
         gen_instr_epilogue(jh);
-        return BRANCH;
+        return ILLEGAL_INSTR;
     }
 };
 
@@ -4795,9 +4795,9 @@ continuation_e vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned
         paddr = this->core.virt2phys(pc);
     auto res = this->core.read(paddr, 4, data);
     if (res != iss::Ok)
-        throw trap_access(TRAP_ID, pc.val);
+        return ILLEGAL_FETCH;
     if (instr == 0x0000006f || (instr&0xffff)==0xa001)
-        throw simulation_stopped(0); // 'J 0' or 'C.J 0'
+        return JUMP_TO_SELF;
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 7e2de93..cbbe348 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -4878,7 +4878,7 @@ private:
         bb = this->leave_blk;
         this->gen_instr_epilogue(bb);
         this->builder.CreateBr(bb);
-        return std::make_tuple(BRANCH, nullptr);
+        return std::make_tuple(ILLEGAL_INSTR, nullptr);
     }    
 };
 
@@ -4913,19 +4913,11 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     auto *const data = (uint8_t *)&instr;
     if(this->core.has_mmu())
         paddr = this->core.virt2phys(pc);
-    //TODO: re-add page handling
-//    if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
-//        auto res = this->core.read(paddr, 2, data);
-//        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//        if ((instr & 0x3) == 0x3) { // this is a 32bit instruction
-//            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
-//        }
-//    } else {
     auto res = this->core.read(paddr, 4, data);
-    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//    }
-    if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-    // curr pc on stack
+    if (res != iss::Ok) 
+        return std::make_tuple(ILLEGAL_FETCH, nullptr);
+    if (instr == 0x0000006f || (instr&0xffff)==0xa001)
+        return std::make_tuple(JUMP_TO_SELF, nullptr);
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 23daf58..71778f6 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -3579,7 +3579,7 @@ private:
         this->gen_set_tval(tu, instr);
         vm_impl::gen_sync(tu, iss::POST_SYNC, instr_descr.size());
         vm_impl::gen_trap_check(tu);
-        return BRANCH;
+        return ILLEGAL_INSTR;
     }
 };
 
@@ -3612,19 +3612,11 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     phys_addr_t paddr(pc);
     if(this->core.has_mmu())
         paddr = this->core.virt2phys(pc);
-    //TODO: re-add page handling
-//    if ((pc.val & upper_bits) != ((pc.val + 2) & upper_bits)) { // we may cross a page boundary
-//        auto res = this->core.read(paddr, 2, data);
-//        if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//        if ((insn & 0x3) == 0x3) { // this is a 32bit instruction
-//            res = this->core.read(this->core.v2p(pc + 2), 2, data + 2);
-//        }
-//    } else {
     auto res = this->core.read(paddr, 4, reinterpret_cast<uint8_t*>(&instr));
-    if (res != iss::Ok) throw trap_access(TRAP_ID, pc.val);
-//    }
-    if (instr == 0x0000006f || (instr&0xffff)==0xa001) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
-    // curr pc on stack
+    if (res != iss::Ok)
+        return ILLEGAL_FETCH;
+    if (instr == 0x0000006f || (instr&0xffff)==0xa001) 
+        return JUMP_TO_SELF;
     ++inst_cnt;
     uint32_t inst_index = instr_decoder.decode_instr(instr);
     compile_func f = nullptr;

From 4a19e279263ca8211a17aac77f6495e4271fff34 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 14 Aug 2024 13:52:08 +0200
Subject: [PATCH 075/100] adds changes due to generator being more inline with
 others

---
 src/vm/llvm/vm_tgc5c.cpp | 784 +++++++++++++++++++--------------------
 1 file changed, 392 insertions(+), 392 deletions(-)

diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index cbbe348..4c8b91b 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -358,8 +358,8 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_const(32,(uint32_t)((int32_t)imm)),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_const(32,(uint32_t)((int32_t)imm)),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -404,8 +404,8 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_const(32,(uint32_t)(PC+(int32_t)imm)),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_const(32,(uint32_t)(PC+(int32_t)imm)),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -456,8 +456,8 @@ private:
             else{
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_const(32,(uint32_t)(PC+4)),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_const(32,(uint32_t)(PC+4)),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
                 auto PC_val_v = new_pc;
                 this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
@@ -510,7 +510,7 @@ private:
             auto new_pc =this->gen_ext(
                 (this->builder.CreateAnd(
                    (this->builder.CreateAdd(
-                      this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                      this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                       this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                    ),
                    this->gen_ext(this->gen_const(32,addr_mask), 64,false))
@@ -533,8 +533,8 @@ private:
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_const(32,(uint32_t)(PC+4)),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_const(32,(uint32_t)(PC+4)),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
                 auto PC_val_v = new_pc;
                 this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
@@ -588,8 +588,8 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
-               this->gen_reg_load(rs1+ traits::X0, 0),
-               this->gen_reg_load(rs2+ traits::X0, 0))
+               this->gen_reg_load(traits::X0+ rs1),
+               this->gen_reg_load(traits::X0+ rs2))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
@@ -651,8 +651,8 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
-               this->gen_reg_load(rs1+ traits::X0, 0),
-               this->gen_reg_load(rs2+ traits::X0, 0))
+               this->gen_reg_load(traits::X0+ rs1),
+               this->gen_reg_load(traits::X0+ rs2))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
@@ -715,10 +715,10 @@ private:
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
                this->gen_ext(
-                   this->gen_reg_load(rs1+ traits::X0, 0),
+                   this->gen_reg_load(traits::X0+ rs1),
                    32, false),
                this->gen_ext(
-                   this->gen_reg_load(rs2+ traits::X0, 0),
+                   this->gen_reg_load(traits::X0+ rs2),
                    32, false))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
@@ -782,10 +782,10 @@ private:
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SGE,
                this->gen_ext(
-                   this->gen_reg_load(rs1+ traits::X0, 0),
+                   this->gen_reg_load(traits::X0+ rs1),
                    32, false),
                this->gen_ext(
-                   this->gen_reg_load(rs2+ traits::X0, 0),
+                   this->gen_reg_load(traits::X0+ rs2),
                    32, false))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
@@ -848,8 +848,8 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
-               this->gen_reg_load(rs1+ traits::X0, 0),
-               this->gen_reg_load(rs2+ traits::X0, 0))
+               this->gen_reg_load(traits::X0+ rs1),
+               this->gen_reg_load(traits::X0+ rs2))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
@@ -911,8 +911,8 @@ private:
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_UGE,
-               this->gen_reg_load(rs1+ traits::X0, 0),
-               this->gen_reg_load(rs2+ traits::X0, 0))
+               this->gen_reg_load(traits::X0+ rs1),
+               this->gen_reg_load(traits::X0+ rs2))
             ), bb_then,  bb_merge);
             this->builder.SetInsertPoint(bb_then);
             {
@@ -972,7 +972,7 @@ private:
         else{
             auto load_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
@@ -981,10 +981,10 @@ private:
                 8, false);
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1030,7 +1030,7 @@ private:
         else{
             auto load_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
@@ -1039,10 +1039,10 @@ private:
                 16, false);
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1088,7 +1088,7 @@ private:
         else{
             auto load_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
@@ -1097,10 +1097,10 @@ private:
                 32, false);
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1146,17 +1146,17 @@ private:
         else{
             auto load_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
             auto res =this->gen_read_mem(traits::MEM, load_address, 1);
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1202,17 +1202,17 @@ private:
         else{
             auto load_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
             auto res =this->gen_read_mem(traits::MEM, load_address, 2);
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1258,14 +1258,14 @@ private:
         else{
             auto store_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
             this->gen_write_mem(traits::MEM,
             store_address,
             this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0),
+                this->gen_reg_load(traits::X0+ rs2),
                 8, false));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1311,14 +1311,14 @@ private:
         else{
             auto store_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
             this->gen_write_mem(traits::MEM,
             store_address,
             this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0),
+                this->gen_reg_load(traits::X0+ rs2),
                 16, false));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1364,14 +1364,14 @@ private:
         else{
             auto store_address =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
                    this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
                 ),
                 32, true);
             this->gen_write_mem(traits::MEM,
             store_address,
             this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0),
+                this->gen_reg_load(traits::X0+ rs2),
                 32, false));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1417,13 +1417,13 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAdd(
-                            this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                            this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
-                         ),
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAdd(
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                       this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 64,true))
+                    ),
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1469,15 +1469,15 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->gen_choose((this->builder.CreateICmp(ICmpInst::ICMP_SLT,
-                        this->gen_ext(
-                            this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                        this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 32,true))
-                     ),
-                     this->gen_const(8,1),
-                     this->gen_const(8,0),
-                     1), 32),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->gen_choose((this->builder.CreateICmp(ICmpInst::ICMP_SLT,
+                   this->gen_ext(
+                       this->gen_reg_load(traits::X0+ rs1), 32,true),
+                   this->gen_ext(this->gen_const(16,(int16_t)sext<12>(imm)), 32,true))
+                ),
+                this->gen_const(8,1),
+                this->gen_const(8,0),
+                1), 32),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1523,14 +1523,14 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->gen_choose((this->builder.CreateICmp(ICmpInst::ICMP_ULT,
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
-                     ),
-                     this->gen_const(8,1),
-                     this->gen_const(8,0),
-                     1), 32),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->gen_choose((this->builder.CreateICmp(ICmpInst::ICMP_ULT,
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
+                ),
+                this->gen_const(8,1),
+                this->gen_const(8,0),
+                1), 32),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1576,11 +1576,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateXor(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateXor(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1626,11 +1626,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateOr(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateOr(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1676,11 +1676,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateAnd(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateAnd(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_const(32,(uint32_t)((int16_t)sext<12>(imm))))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1726,11 +1726,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateShl(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_ext(this->gen_const(8,shamt), 32,false))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateShl(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_ext(this->gen_const(8,shamt), 32,false))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1776,11 +1776,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateLShr(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_ext(this->gen_const(8,shamt), 32,false))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateLShr(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_ext(this->gen_const(8,shamt), 32,false))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1826,13 +1826,13 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAShr(
-                            this->gen_ext(
-                                this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                            this->gen_ext(this->gen_const(8,shamt), 32,false))
-                         ), 32,false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAShr(
+                       this->gen_ext(
+                           this->gen_reg_load(traits::X0+ rs1), 32,true),
+                       this->gen_ext(this->gen_const(8,shamt), 32,false))
+                    ), 32,false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1878,13 +1878,13 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAdd(
-                            this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                            this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
-                         ),
-                         32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAdd(
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false))
+                    ),
+                    32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1930,13 +1930,13 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateSub(
-                            this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                            this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
-                         ),
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateSub(
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false))
+                    ),
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -1982,14 +1982,14 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->builder.CreateShl(
-                        this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                        (this->builder.CreateAnd(
-                           this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false),
-                           this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
-                        ))
-                     , 32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->builder.CreateShl(
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                   (this->builder.CreateAnd(
+                      this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false),
+                      this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
+                   ))
+                , 32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2035,16 +2035,16 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->gen_choose(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
-                        this->gen_ext(
-                            this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                        this->gen_ext(
-                            this->gen_reg_load(rs2+ traits::X0, 0), 32,true))
-                     ,
-                     this->gen_const(8,1),
-                     this->gen_const(8,0),
-                     1), 32),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->gen_choose(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
+                   this->gen_ext(
+                       this->gen_reg_load(traits::X0+ rs1), 32,true),
+                   this->gen_ext(
+                       this->gen_reg_load(traits::X0+ rs2), 32,true))
+                ,
+                this->gen_const(8,1),
+                this->gen_const(8,0),
+                1), 32),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2090,14 +2090,14 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->gen_choose(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_reg_load(rs2+ traits::X0, 0))
-                     ,
-                     this->gen_const(8,1),
-                     this->gen_const(8,0),
-                     1), 32),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->gen_choose(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_reg_load(traits::X0+ rs2))
+                ,
+                this->gen_const(8,1),
+                this->gen_const(8,0),
+                1), 32),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2143,11 +2143,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateXor(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_reg_load(rs2+ traits::X0, 0))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateXor(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_reg_load(traits::X0+ rs2))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2193,14 +2193,14 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(this->builder.CreateLShr(
-                        this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                        (this->builder.CreateAnd(
-                           this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false),
-                           this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
-                        ))
-                     , 32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(this->builder.CreateLShr(
+                   this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                   (this->builder.CreateAnd(
+                      this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false),
+                      this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
+                   ))
+                , 32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2246,17 +2246,17 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->gen_ext(this->builder.CreateAShr(
-                            this->gen_ext(this->gen_ext(
-                                this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
-                            (this->builder.CreateAnd(
-                               this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false),
-                               this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
-                            ))
-                         , 32, true)),
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->gen_ext(this->builder.CreateAShr(
+                       this->gen_ext(this->gen_ext(
+                           this->gen_reg_load(traits::X0+ rs1), 32,true), 64,true),
+                       (this->builder.CreateAnd(
+                          this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false),
+                          this->gen_const(64,(static_cast<uint32_t>(traits::XLEN)-1)))
+                       ))
+                    , 32, true)),
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2302,11 +2302,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateOr(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_reg_load(rs2+ traits::X0, 0))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateOr(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_reg_load(traits::X0+ rs2))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2352,11 +2352,11 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateAnd(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_reg_load(rs2+ traits::X0, 0))
-                     ,
-                     get_reg_ptr(rd + traits::X0), false);
+                this->builder.CreateAnd(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_reg_load(traits::X0+ rs2))
+                ,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2581,14 +2581,14 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
-            auto xrs1 =this->gen_reg_load(rs1+ traits::X0, 0);
+            auto xrs1 =this->gen_reg_load(traits::X0+ rs1);
             if(rd!=0){ auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
             this->gen_write_mem(traits::CSR,
             csr,
             xrs1);
             this->builder.CreateStore(
-                 xrd,
-                 get_reg_ptr(rd + traits::X0), false);
+            xrd,
+            get_reg_ptr(rd + traits::X0), false);
             }
             else{
                 this->gen_write_mem(traits::CSR,
@@ -2638,7 +2638,7 @@ private:
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
-            auto xrs1 =this->gen_reg_load(rs1+ traits::X0, 0);
+            auto xrs1 =this->gen_reg_load(traits::X0+ rs1);
             if(rs1!=0) {
                 this->gen_write_mem(traits::CSR,
                 csr,
@@ -2649,8 +2649,8 @@ private:
             }
             if(rd!=0) {
                 this->builder.CreateStore(
-                     xrd,
-                     get_reg_ptr(rd + traits::X0), false);
+                xrd,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2695,7 +2695,7 @@ private:
         }
         else{
             auto xrd =this->gen_read_mem(traits::CSR, csr, 4);
-            auto xrs1 =this->gen_reg_load(rs1+ traits::X0, 0);
+            auto xrs1 =this->gen_reg_load(traits::X0+ rs1);
             if(rs1!=0) {
                 this->gen_write_mem(traits::CSR,
                 csr,
@@ -2706,8 +2706,8 @@ private:
             }
             if(rd!=0) {
                 this->builder.CreateStore(
-                     xrd,
-                     get_reg_ptr(rd + traits::X0), false);
+                xrd,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2757,8 +2757,8 @@ private:
             this->gen_const(32,(uint32_t)zimm));
             if(rd!=0) {
                 this->builder.CreateStore(
-                     xrd,
-                     get_reg_ptr(rd + traits::X0), false);
+                xrd,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2813,8 +2813,8 @@ private:
             }
             if(rd!=0) {
                 this->builder.CreateStore(
-                     xrd,
-                     get_reg_ptr(rd + traits::X0), false);
+                xrd,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2869,8 +2869,8 @@ private:
             }
             if(rd!=0) {
                 this->builder.CreateStore(
-                     xrd,
-                     get_reg_ptr(rd + traits::X0), false);
+                xrd,
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2956,16 +2956,16 @@ private:
         else{
             auto res =this->builder.CreateMul(
                this->gen_ext(this->gen_ext(
-                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
+                   this->gen_reg_load(traits::X0+ rs1), 32,true), 64,true),
                this->gen_ext(this->gen_ext(
-                   this->gen_reg_load(rs2+ traits::X0, 0), 32,true), 64,true))
+                   this->gen_reg_load(traits::X0+ rs2), 32,true), 64,true))
             ;
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         res,
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    res,
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3011,19 +3011,19 @@ private:
         else{
             auto res =this->builder.CreateMul(
                this->gen_ext(this->gen_ext(
-                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
+                   this->gen_reg_load(traits::X0+ rs1), 32,true), 64,true),
                this->gen_ext(this->gen_ext(
-                   this->gen_reg_load(rs2+ traits::X0, 0), 32,true), 64,true))
+                   this->gen_reg_load(traits::X0+ rs2), 32,true), 64,true))
             ;
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAShr(
-                            res,
-                            this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
-                         ),
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAShr(
+                       res,
+                       this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
+                    ),
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3069,18 +3069,18 @@ private:
         else{
             auto res =this->builder.CreateMul(
                this->gen_ext(this->gen_ext(
-                   this->gen_reg_load(rs1+ traits::X0, 0), 32,true), 64,true),
-               this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
+                   this->gen_reg_load(traits::X0+ rs1), 32,true), 64,true),
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false))
             ;
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAShr(
-                            res,
-                            this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
-                         ),
-                         32, true),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAShr(
+                       res,
+                       this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
+                    ),
+                    32, true),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3125,18 +3125,18 @@ private:
         }
         else{
             auto res =this->builder.CreateMul(
-               this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-               this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false))
             ;
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateLShr(
-                            res,
-                            this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
-                         ),
-                         32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateLShr(
+                       res,
+                       this->gen_ext(this->gen_const(32,static_cast<uint32_t>(traits::XLEN)), 64,false))
+                    ),
+                    32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3181,9 +3181,9 @@ private:
         }
         else{
             auto dividend =this->gen_ext(
-                this->gen_reg_load(rs1+ traits::X0, 0), 32,true);
+                this->gen_reg_load(traits::X0+ rs1), 32,true);
             auto divisor =this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0), 32,true);
+                this->gen_reg_load(traits::X0+ rs2), 32,true);
             if(rd!=0){ auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3199,7 +3199,7 @@ private:
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
                 this->builder.CreateCondBr(this->gen_bool(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
-                      this->gen_reg_load(rs1+ traits::X0, 0),
+                      this->gen_reg_load(traits::X0+ rs1),
                       this->gen_const(32,MMIN))
                    ,
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
@@ -3210,20 +3210,20 @@ private:
                 this->builder.SetInsertPoint(bb_then);
                 {
                     this->builder.CreateStore(
-                         this->gen_const(32,MMIN),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_const(32,MMIN),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
                 this->builder.CreateBr(bb_merge);
                 this->builder.SetInsertPoint(bb_else);
                 {
                     this->builder.CreateStore(
-                         this->gen_ext(
-                             (this->builder.CreateSDiv(
-                                this->gen_ext(dividend, 64,true),
-                                this->gen_ext(divisor, 64,true))
-                             ),
-                             32, true),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_ext(
+                        (this->builder.CreateSDiv(
+                           this->gen_ext(dividend, 64,true),
+                           this->gen_ext(divisor, 64,true))
+                        ),
+                        32, true),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
                 this->builder.CreateBr(bb_merge);
                 this->builder.SetInsertPoint(bb_merge);
@@ -3232,8 +3232,8 @@ private:
             this->builder.SetInsertPoint(bb_else);
             {
                 this->builder.CreateStore(
-                     this->gen_const(32,(uint32_t)- 1),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_const(32,(uint32_t)- 1),
+                get_reg_ptr(rd + traits::X0), false);
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
@@ -3284,18 +3284,18 @@ private:
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
-               this->gen_reg_load(rs2+ traits::X0, 0),
+               this->gen_reg_load(traits::X0+ rs2),
                this->gen_ext(this->gen_const(8,0), 32,false))
             ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->builder.CreateUDiv(
-                            this->gen_reg_load(rs1+ traits::X0, 0),
-                            this->gen_reg_load(rs2+ traits::X0, 0))
-                         ,
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->builder.CreateUDiv(
+                       this->gen_reg_load(traits::X0+ rs1),
+                       this->gen_reg_load(traits::X0+ rs2))
+                    ,
+                    get_reg_ptr(rd + traits::X0), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -3303,8 +3303,8 @@ private:
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_const(32,(uint32_t)- 1),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_const(32,(uint32_t)- 1),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -3355,7 +3355,7 @@ private:
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
-               this->gen_reg_load(rs2+ traits::X0, 0),
+               this->gen_reg_load(traits::X0+ rs2),
                this->gen_ext(this->gen_const(8,0), 32,false))
             ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
@@ -3366,12 +3366,12 @@ private:
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
                 this->builder.CreateCondBr(this->gen_bool(this->builder.CreateAnd(
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
-                      this->gen_reg_load(rs1+ traits::X0, 0),
+                      this->gen_reg_load(traits::X0+ rs1),
                       this->gen_const(32,MMIN))
                    ,
                    this->builder.CreateICmp(ICmpInst::ICMP_EQ,
                       this->gen_ext(
-                          this->gen_reg_load(rs2+ traits::X0, 0),
+                          this->gen_reg_load(traits::X0+ rs2),
                           32, false),
                       this->gen_ext(this->gen_const(8,- 1), 32,true))
                    )
@@ -3380,8 +3380,8 @@ private:
                 {
                     if(rd!=0) {
                         this->builder.CreateStore(
-                             this->gen_ext(this->gen_const(8,0), 32),
-                             get_reg_ptr(rd + traits::X0), false);
+                        this->gen_ext(this->gen_const(8,0), 32),
+                        get_reg_ptr(rd + traits::X0), false);
                     }
                 }
                 this->builder.CreateBr(bb_merge);
@@ -3389,14 +3389,14 @@ private:
                 {
                     if(rd!=0) {
                         this->builder.CreateStore(
-                             this->gen_ext(
-                                 (this->builder.CreateSRem(
-                                    this->gen_ext(
-                                        this->gen_reg_load(rs1+ traits::X0, 0), 32,true),
-                                    this->gen_ext(
-                                        this->gen_reg_load(rs2+ traits::X0, 0), 32,true))
-                                 ), 32,false),
-                             get_reg_ptr(rd + traits::X0), false);
+                        this->gen_ext(
+                            (this->builder.CreateSRem(
+                               this->gen_ext(
+                                   this->gen_reg_load(traits::X0+ rs1), 32,true),
+                               this->gen_ext(
+                                   this->gen_reg_load(traits::X0+ rs2), 32,true))
+                            ), 32,false),
+                        get_reg_ptr(rd + traits::X0), false);
                     }
                 }
                 this->builder.CreateBr(bb_merge);
@@ -3407,8 +3407,8 @@ private:
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_reg_load(rs1+ traits::X0, 0),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_reg_load(traits::X0+ rs1),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -3459,18 +3459,18 @@ private:
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
-               this->gen_reg_load(rs2+ traits::X0, 0),
+               this->gen_reg_load(traits::X0+ rs2),
                this->gen_ext(this->gen_const(8,0), 32,false))
             ), bb_then, bb_else);
             this->builder.SetInsertPoint(bb_then);
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->builder.CreateURem(
-                            this->gen_reg_load(rs1+ traits::X0, 0),
-                            this->gen_reg_load(rs2+ traits::X0, 0))
-                         ,
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->builder.CreateURem(
+                       this->gen_reg_load(traits::X0+ rs1),
+                       this->gen_reg_load(traits::X0+ rs2))
+                    ,
+                    get_reg_ptr(rd + traits::X0), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -3478,8 +3478,8 @@ private:
             {
                 if(rd!=0) {
                     this->builder.CreateStore(
-                         this->gen_reg_load(rs1+ traits::X0, 0),
-                         get_reg_ptr(rd + traits::X0), false);
+                    this->gen_reg_load(traits::X0+ rs1),
+                    get_reg_ptr(rd + traits::X0), false);
                 }
             }
             this->builder.CreateBr(bb_merge);
@@ -3523,13 +3523,13 @@ private:
         /*generate behavior*/
         if(imm) {
             this->builder.CreateStore(
-                 this->gen_ext(
-                     (this->builder.CreateAdd(
-                        this->gen_ext(this->gen_reg_load(2+ traits::X0, 0), 64,false),
-                        this->gen_ext(this->gen_const(16,imm), 64,false))
-                     ),
-                     32, false),
-                 get_reg_ptr(rd+8 + traits::X0), false);
+            this->gen_ext(
+                (this->builder.CreateAdd(
+                   this->gen_ext(this->gen_reg_load(traits::X0+ 2), 64,false),
+                   this->gen_ext(this->gen_const(16,imm), 64,false))
+                ),
+                32, false),
+            get_reg_ptr(rd+8 + traits::X0), false);
         }
         else{
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3573,17 +3573,17 @@ private:
         /*generate behavior*/
         auto offs =this->gen_ext(
             (this->builder.CreateAdd(
-               this->gen_ext(this->gen_reg_load(rs1+8+ traits::X0, 0), 64,false),
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs1+8), 64,false),
                this->gen_ext(this->gen_const(8,uimm), 64,false))
             ),
             32, false);
         this->builder.CreateStore(
-             this->gen_ext(
-                 this->gen_ext(
-                     this->gen_read_mem(traits::MEM, offs, 4),
-                     32, false),
-                 32, true),
-             get_reg_ptr(rd+8 + traits::X0), false);
+        this->gen_ext(
+            this->gen_ext(
+                this->gen_read_mem(traits::MEM, offs, 4),
+                32, false),
+            32, true),
+        get_reg_ptr(rd+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -3623,14 +3623,14 @@ private:
         /*generate behavior*/
         auto offs =this->gen_ext(
             (this->builder.CreateAdd(
-               this->gen_ext(this->gen_reg_load(rs1+8+ traits::X0, 0), 64,false),
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs1+8), 64,false),
                this->gen_ext(this->gen_const(8,uimm), 64,false))
             ),
             32, false);
         this->gen_write_mem(traits::MEM,
         offs,
         this->gen_ext(
-            this->gen_reg_load(rs2+8+ traits::X0, 0),
+            this->gen_reg_load(traits::X0+ rs2+8),
             32, false));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3674,13 +3674,13 @@ private:
         else{
             if(rs1!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAdd(
-                            this->gen_ext(this->gen_reg_load(rs1+ traits::X0, 0), 64,false),
-                            this->gen_ext(this->gen_const(8,(int8_t)sext<6>(imm)), 64,true))
-                         ),
-                         32, true),
-                     get_reg_ptr(rs1 + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAdd(
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs1), 64,false),
+                       this->gen_ext(this->gen_const(8,(int8_t)sext<6>(imm)), 64,true))
+                    ),
+                    32, true),
+                get_reg_ptr(rs1 + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3754,8 +3754,8 @@ private:
         /*generate behavior*/
         this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         this->builder.CreateStore(
-             this->gen_const(32,(uint32_t)(PC+2)),
-             get_reg_ptr(1 + traits::X0), false);
+        this->gen_const(32,(uint32_t)(PC+2)),
+        get_reg_ptr(1 + traits::X0), false);
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
         this->builder.CreateStore(this->gen_const(32,PC_val_v), get_reg_ptr(traits::NEXT_PC), false);
         this->builder.CreateStore(this->gen_const(32, static_cast<int>(KNOWN_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
@@ -3801,8 +3801,8 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_const(32,(uint32_t)((int8_t)sext<6>(imm))),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_const(32,(uint32_t)((int8_t)sext<6>(imm))),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -3846,8 +3846,8 @@ private:
         }
         if(rd!=0) {
             this->builder.CreateStore(
-                 this->gen_const(32,(uint32_t)((int32_t)sext<18>(imm))),
-                 get_reg_ptr(rd + traits::X0), false);
+            this->gen_const(32,(uint32_t)((int32_t)sext<18>(imm))),
+            get_reg_ptr(rd + traits::X0), false);
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3886,13 +3886,13 @@ private:
         /*generate behavior*/
         if(nzimm) {
             this->builder.CreateStore(
-                 this->gen_ext(
-                     (this->builder.CreateAdd(
-                        this->gen_ext(this->gen_reg_load(2+ traits::X0, 0), 64,false),
-                        this->gen_ext(this->gen_const(16,(int16_t)sext<10>(nzimm)), 64,true))
-                     ),
-                     32, true),
-                 get_reg_ptr(2 + traits::X0), false);
+            this->gen_ext(
+                (this->builder.CreateAdd(
+                   this->gen_ext(this->gen_reg_load(traits::X0+ 2), 64,false),
+                   this->gen_ext(this->gen_const(16,(int16_t)sext<10>(nzimm)), 64,true))
+                ),
+                32, true),
+            get_reg_ptr(2 + traits::X0), false);
         }
         else{
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
@@ -3969,11 +3969,11 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->builder.CreateLShr(
-                this->gen_reg_load(rs1+8+ traits::X0, 0),
-                this->gen_ext(this->gen_const(8,shamt), 32,false))
-             ,
-             get_reg_ptr(rs1+8 + traits::X0), false);
+        this->builder.CreateLShr(
+           this->gen_reg_load(traits::X0+ rs1+8),
+           this->gen_ext(this->gen_const(8,shamt), 32,false))
+        ,
+        get_reg_ptr(rs1+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4011,27 +4011,27 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         if(shamt){ this->builder.CreateStore(
-             this->gen_ext(
-                 (this->builder.CreateAShr(
-                    (this->gen_ext(
-                        this->gen_reg_load(rs1+8+ traits::X0, 0),
-                        32, false)),
-                    this->gen_ext(this->gen_const(8,shamt), 32,false))
-                 ),
-                 32, true),
-             get_reg_ptr(rs1+8 + traits::X0), false);
+        this->gen_ext(
+            (this->builder.CreateAShr(
+               (this->gen_ext(
+                   this->gen_reg_load(traits::X0+ rs1+8),
+                   32, false)),
+               this->gen_ext(this->gen_const(8,shamt), 32,false))
+            ),
+            32, true),
+        get_reg_ptr(rs1+8 + traits::X0), false);
         }
         else{
             if(static_cast<uint32_t>(traits::XLEN)==128){ this->builder.CreateStore(
-                 this->gen_ext(
-                     (this->builder.CreateAShr(
-                        (this->gen_ext(
-                            this->gen_reg_load(rs1+8+ traits::X0, 0),
-                            32, false)),
-                        this->gen_ext(this->gen_const(8,64), 32,false))
-                     ),
-                     32, true),
-                 get_reg_ptr(rs1+8 + traits::X0), false);
+            this->gen_ext(
+                (this->builder.CreateAShr(
+                   (this->gen_ext(
+                       this->gen_reg_load(traits::X0+ rs1+8),
+                       32, false)),
+                   this->gen_ext(this->gen_const(8,64), 32,false))
+                ),
+                32, true),
+            get_reg_ptr(rs1+8 + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4071,13 +4071,13 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->gen_ext(
-                 (this->builder.CreateAnd(
-                    this->gen_reg_load(rs1+8+ traits::X0, 0),
-                    this->gen_ext(this->gen_const(8,(int8_t)sext<6>(imm)), 32,true))
-                 ),
-                 32, true),
-             get_reg_ptr(rs1+8 + traits::X0), false);
+        this->gen_ext(
+            (this->builder.CreateAnd(
+               this->gen_reg_load(traits::X0+ rs1+8),
+               this->gen_ext(this->gen_const(8,(int8_t)sext<6>(imm)), 32,true))
+            ),
+            32, true),
+        get_reg_ptr(rs1+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4115,13 +4115,13 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->gen_ext(
-                 (this->builder.CreateSub(
-                    this->gen_ext(this->gen_reg_load(rd+8+ traits::X0, 0), 64,false),
-                    this->gen_ext(this->gen_reg_load(rs2+8+ traits::X0, 0), 64,false))
-                 ),
-                 32, true),
-             get_reg_ptr(rd+8 + traits::X0), false);
+        this->gen_ext(
+            (this->builder.CreateSub(
+               this->gen_ext(this->gen_reg_load(traits::X0+ rd+8), 64,false),
+               this->gen_ext(this->gen_reg_load(traits::X0+ rs2+8), 64,false))
+            ),
+            32, true),
+        get_reg_ptr(rd+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4159,11 +4159,11 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->builder.CreateXor(
-                this->gen_reg_load(rd+8+ traits::X0, 0),
-                this->gen_reg_load(rs2+8+ traits::X0, 0))
-             ,
-             get_reg_ptr(rd+8 + traits::X0), false);
+        this->builder.CreateXor(
+           this->gen_reg_load(traits::X0+ rd+8),
+           this->gen_reg_load(traits::X0+ rs2+8))
+        ,
+        get_reg_ptr(rd+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4201,11 +4201,11 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->builder.CreateOr(
-                this->gen_reg_load(rd+8+ traits::X0, 0),
-                this->gen_reg_load(rs2+8+ traits::X0, 0))
-             ,
-             get_reg_ptr(rd+8 + traits::X0), false);
+        this->builder.CreateOr(
+           this->gen_reg_load(traits::X0+ rd+8),
+           this->gen_reg_load(traits::X0+ rs2+8))
+        ,
+        get_reg_ptr(rd+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4243,11 +4243,11 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(
-             this->builder.CreateAnd(
-                this->gen_reg_load(rd+8+ traits::X0, 0),
-                this->gen_reg_load(rs2+8+ traits::X0, 0))
-             ,
-             get_reg_ptr(rd+8 + traits::X0), false);
+        this->builder.CreateAnd(
+           this->gen_reg_load(traits::X0+ rd+8),
+           this->gen_reg_load(traits::X0+ rs2+8))
+        ,
+        get_reg_ptr(rd+8 + traits::X0), false);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4327,7 +4327,7 @@ private:
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
-           this->gen_reg_load(rs1+8+ traits::X0, 0),
+           this->gen_reg_load(traits::X0+ rs1+8),
            this->gen_ext(this->gen_const(8,0), 32,false))
         ), bb_then,  bb_merge);
         this->builder.SetInsertPoint(bb_then);
@@ -4378,7 +4378,7 @@ private:
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
-           this->gen_reg_load(rs1+8+ traits::X0, 0),
+           this->gen_reg_load(traits::X0+ rs1+8),
            this->gen_ext(this->gen_const(8,0), 32,false))
         ), bb_then,  bb_merge);
         this->builder.SetInsertPoint(bb_then);
@@ -4431,11 +4431,11 @@ private:
         else{
             if(rs1!=0) {
                 this->builder.CreateStore(
-                     this->builder.CreateShl(
-                        this->gen_reg_load(rs1+ traits::X0, 0),
-                        this->gen_ext(this->gen_const(8,nzuimm), 32,false))
-                     ,
-                     get_reg_ptr(rs1 + traits::X0), false);
+                this->builder.CreateShl(
+                   this->gen_reg_load(traits::X0+ rs1),
+                   this->gen_ext(this->gen_const(8,nzuimm), 32,false))
+                ,
+                get_reg_ptr(rs1 + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4480,17 +4480,17 @@ private:
         else{
             auto offs =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(2+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ 2), 64,false),
                    this->gen_ext(this->gen_const(8,uimm), 64,false))
                 ),
                 32, false);
             this->builder.CreateStore(
-                 this->gen_ext(
-                     this->gen_ext(
-                         this->gen_read_mem(traits::MEM, offs, 4),
-                         32, false),
-                     32, true),
-                 get_reg_ptr(rd + traits::X0), false);
+            this->gen_ext(
+                this->gen_ext(
+                    this->gen_read_mem(traits::MEM, offs, 4),
+                    32, false),
+                32, true),
+            get_reg_ptr(rd + traits::X0), false);
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -4534,8 +4534,8 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_reg_load(rs2+ traits::X0, 0),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_reg_load(traits::X0+ rs2),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4576,7 +4576,7 @@ private:
         this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
         auto PC_val_v = this->builder.CreateAnd(
-           this->gen_reg_load(rs1%static_cast<uint32_t>(traits::RFS)+ traits::X0, 0),
+           this->gen_reg_load(traits::X0+ rs1%static_cast<uint32_t>(traits::RFS)),
            this->gen_const(32,addr_mask))
         ;
         this->builder.CreateStore(PC_val_v, get_reg_ptr(traits::NEXT_PC), false);                            
@@ -4661,13 +4661,13 @@ private:
         else{
             if(rd!=0) {
                 this->builder.CreateStore(
-                     this->gen_ext(
-                         (this->builder.CreateAdd(
-                            this->gen_ext(this->gen_reg_load(rd+ traits::X0, 0), 64,false),
-                            this->gen_ext(this->gen_reg_load(rs2+ traits::X0, 0), 64,false))
-                         ),
-                         32, false),
-                     get_reg_ptr(rd + traits::X0), false);
+                this->gen_ext(
+                    (this->builder.CreateAdd(
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rd), 64,false),
+                       this->gen_ext(this->gen_reg_load(traits::X0+ rs2), 64,false))
+                    ),
+                    32, false),
+                get_reg_ptr(rd + traits::X0), false);
             }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -4711,10 +4711,10 @@ private:
         }
         else{
             auto addr_mask =(uint32_t)- 2;
-            auto new_pc =this->gen_reg_load(rs1+ traits::X0, 0);
+            auto new_pc =this->gen_reg_load(traits::X0+ rs1);
             this->builder.CreateStore(
-                 this->gen_const(32,(uint32_t)(PC+2)),
-                 get_reg_ptr(1 + traits::X0), false);
+            this->gen_const(32,(uint32_t)(PC+2)),
+            get_reg_ptr(1 + traits::X0), false);
             auto PC_val_v = this->builder.CreateAnd(
                new_pc,
                this->gen_const(32,addr_mask))
@@ -4798,14 +4798,14 @@ private:
         else{
             auto offs =this->gen_ext(
                 (this->builder.CreateAdd(
-                   this->gen_ext(this->gen_reg_load(2+ traits::X0, 0), 64,false),
+                   this->gen_ext(this->gen_reg_load(traits::X0+ 2), 64,false),
                    this->gen_ext(this->gen_const(8,uimm), 64,false))
                 ),
                 32, false);
             this->gen_write_mem(traits::MEM,
             offs,
             this->gen_ext(
-                this->gen_reg_load(rs2+ traits::X0, 0),
+                this->gen_reg_load(traits::X0+ rs2),
                 32, false));
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);

From efc11d87a57fb973f5f7e9cefe6d92ec84a22442 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 14 Aug 2024 14:32:58 +0200
Subject: [PATCH 076/100] updates template with fcsr check, adds extra braces
 on If Statements

---
 gen_input/templates/llvm/CORENAME.cpp.gtl | 14 +++++++---
 src/vm/llvm/vm_tgc5c.cpp                  | 34 +++++++++++++++++++++--
 2 files changed, 42 insertions(+), 6 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 9c90f61..f362493 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -37,7 +37,9 @@
 #include <iss/llvm/vm_base.h>
 #include <util/logging.h>
 #include <iss/instruction_decoder.h>
-
+<%def fcsr = registers.find {it.name=='FCSR'}
+if(fcsr != null) {%>
+#include <vm/fp_functions.h><%}%>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
 #endif
@@ -83,7 +85,9 @@ protected:
     using vm_base<ARCH>::get_reg_ptr;
 
     inline const char *name(size_t index){return traits::reg_aliases.at(index);}
-
+<%if(fcsr != null) {%>
+    inline const char *fname(size_t index){return index < 32?name(index+traits::F0):"illegal";}   
+<%}%>
     template <typename T> inline ConstantInt *size(T type) {
         return ConstantInt::get(getContext(), APInt(32, type->getType()->getScalarSizeInBits()));
     }
@@ -130,8 +134,10 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    }   
-
+    }
+<%functions.each{ it.eachLine { %>
+    ${it}<%}%>
+<%}%>
 private:
     /****************************************************************************
      * start opcode definitions
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 4c8b91b..b928011 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -130,7 +130,7 @@ protected:
         auto mask = (1ULL<<W) - 1;
         auto sign_mask = 1ULL<<(W-1);
         return (from & mask) | ((from & sign_mask) ? ~mask : 0);
-    }   
+    }
 
 private:
     /****************************************************************************
@@ -516,6 +516,7 @@ private:
                    this->gen_ext(this->gen_const(32,addr_mask), 64,false))
                 ),
                 32, true);
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -542,6 +543,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -585,6 +587,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
@@ -605,6 +608,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -648,6 +652,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
@@ -668,6 +673,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -711,6 +717,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SLT,
@@ -735,6 +742,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -778,6 +786,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_SGE,
@@ -802,6 +811,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -845,6 +855,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_ULT,
@@ -865,6 +876,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -908,6 +920,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_UGE,
@@ -928,6 +941,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
@@ -3184,7 +3198,8 @@ private:
                 this->gen_reg_load(traits::X0+ rs1), 32,true);
             auto divisor =this->gen_ext(
                 this->gen_reg_load(traits::X0+ rs2), 32,true);
-            if(rd!=0){ auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
+            if(rd!=0){ {
+            auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
             this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
@@ -3194,6 +3209,7 @@ private:
             this->builder.SetInsertPoint(bb_then);
             {
                 auto MMIN =((uint32_t)1)<<(static_cast<uint32_t>(traits::XLEN)-1);
+                {
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3227,6 +3243,7 @@ private:
                 }
                 this->builder.CreateBr(bb_merge);
                 this->builder.SetInsertPoint(bb_merge);
+                }
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_else);
@@ -3238,6 +3255,7 @@ private:
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
             }
+            }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3280,6 +3298,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3309,6 +3328,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3351,6 +3371,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3361,6 +3382,7 @@ private:
             this->builder.SetInsertPoint(bb_then);
             {
                 auto MMIN =(uint32_t)1<<(static_cast<uint32_t>(traits::XLEN)-1);
+                {
                 auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
                 auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
                 auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3401,6 +3423,7 @@ private:
                 }
                 this->builder.CreateBr(bb_merge);
                 this->builder.SetInsertPoint(bb_merge);
+                }
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_else);
@@ -3413,6 +3436,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -3455,6 +3479,7 @@ private:
             this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         }
         else{
+            {
             auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
             auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
             auto bb_else = BasicBlock::Create(this->mod->getContext(), "bb_else", this->func, bb_merge);
@@ -3484,6 +3509,7 @@ private:
             }
             this->builder.CreateBr(bb_merge);
             this->builder.SetInsertPoint(bb_merge);
+            }
         }
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
@@ -4324,6 +4350,7 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
+        {
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_EQ,
@@ -4338,6 +4365,7 @@ private:
         }
         this->builder.CreateBr(bb_merge);
         this->builder.SetInsertPoint(bb_merge);
+        }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
@@ -4375,6 +4403,7 @@ private:
         this->gen_instr_prologue();
         /*generate behavior*/
         this->builder.CreateStore(this->gen_const(32U, static_cast<int>(NO_JUMP)), get_reg_ptr(traits::LAST_BRANCH), false);
+        {
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
         auto bb_then = BasicBlock::Create(this->mod->getContext(), "bb_then", this->func, bb_merge);
         this->builder.CreateCondBr(this->gen_bool(this->builder.CreateICmp(ICmpInst::ICMP_NE,
@@ -4389,6 +4418,7 @@ private:
         }
         this->builder.CreateBr(bb_merge);
         this->builder.SetInsertPoint(bb_merge);
+        }
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         

From 0f15032210255e0b7ca3d78b3a0c7d9dfb184c88 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Wed, 14 Aug 2024 15:25:06 +0200
Subject: [PATCH 077/100] removes gen_wait as wait can be called like any other
 extern function

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 1 -
 src/vm/asmjit/vm_tgc5c.cpp                  | 6 ++++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 47b07ca..7efab21 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -90,7 +90,6 @@ protected:
     using super::write_reg_to_mem;
     using super::gen_read_mem;
     using super::gen_write_mem;
-    using super::gen_wait;
     using super::gen_leave;
     using super::gen_sync;
    
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index deb5004..19e10a6 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -88,7 +88,6 @@ protected:
     using super::write_reg_to_mem;
     using super::gen_read_mem;
     using super::gen_write_mem;
-    using super::gen_wait;
     using super::gen_leave;
     using super::gen_sync;
    
@@ -2512,7 +2511,10 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        gen_wait(jh, 1);
+        InvokeNode* call_wait;
+        jh.cc.comment("//call_wait");
+        jh.cc.invoke(&call_wait, &wait, FuncSignature::build<void, int32_t>());
+        setArg(call_wait, 0, 1);
         auto returnValue = CONT;
         
         gen_sync(jh, POST_SYNC, 41);

From a45fcd28db032099aaa24b3a6472f957cbe3c4b9 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Sat, 17 Aug 2024 08:22:04 +0200
Subject: [PATCH 078/100] updates fn calling generation

---
 src/vm/llvm/vm_tgc5c.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index b928011..1aafb8b 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -2553,7 +2553,11 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
-        this->gen_wait(1);
+        auto wait_arg0 = this->gen_const(8,1);
+        std::vector<Value*> wait_args{
+            wait_arg0
+        };
+        this->builder.CreateCall(this->mod->getFunction("wait"), wait_args);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         

From 0473aa53446f6ad67cef6e9c6dca77328b0c7137 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 12:34:17 +0200
Subject: [PATCH 079/100] fixes SystemC wrapper wrt. templated core_complex

---
 src/sysc/core_complex.cpp   |  5 ++---
 src/sysc/core_complex.h     |  1 +
 src/sysc/register_tgc_c.cpp | 12 ++++++------
 src/sysc/sc_core_adapter.h  |  2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/sysc/core_complex.cpp b/src/sysc/core_complex.cpp
index da8fd3f..7753ddf 100644
--- a/src/sysc/core_complex.cpp
+++ b/src/sysc/core_complex.cpp
@@ -125,7 +125,7 @@ using vm_ptr = std::unique_ptr<iss::vm_if>;
 
 class core_wrapper {
 public:
-    core_wrapper(core_complex* owner)
+    core_wrapper(core_complex_if* owner)
     : owner(owner) {}
 
     void reset(uint64_t addr) { vm->reset(addr); }
@@ -181,7 +181,7 @@ public:
                                              "SystemC sub-commands: break <time>, print_time"});
     }
 
-    core_complex* const owner;
+    core_complex_if* const owner;
     vm_ptr vm{nullptr};
     sc_cpu_ptr cpu{nullptr};
     iss::debugger::target_adapter_if* tgt_adapter{nullptr};
@@ -197,7 +197,6 @@ struct core_trace {
     scv_tr_handle tr_handle;
 };
 
-SC_HAS_PROCESS(core_complex); // NOLINT
 #ifndef CWR_SYSTEMC
 template <unsigned int BUSWIDTH>
 core_complex<BUSWIDTH>::core_complex(sc_module_name const& name)
diff --git a/src/sysc/core_complex.h b/src/sysc/core_complex.h
index 7f0bc08..b44050f 100644
--- a/src/sysc/core_complex.h
+++ b/src/sysc/core_complex.h
@@ -83,6 +83,7 @@ struct core_complex_if {
 
     virtual unsigned get_last_bus_cycles() =0;
 
+    //! Allow quantum keeper handling
     virtual void sync(uint64_t) =0;
 
     virtual char const* hier_name() = 0;
diff --git a/src/sysc/register_tgc_c.cpp b/src/sysc/register_tgc_c.cpp
index ecbcc16..d2c3c49 100644
--- a/src/sysc/register_tgc_c.cpp
+++ b/src/sysc/register_tgc_c.cpp
@@ -46,12 +46,12 @@ using namespace sysc;
 volatile std::array<bool, 2> tgc_init = {
     iss_factory::instance().register_creator("tgc5c|m_p|interp",
                                              [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
                                                  auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::tgc5c>>(cc);
                                                  return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("tgc5c|mu_p|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-        auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+        auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
         auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::tgc5c>>(cc);
         return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
     })};
@@ -79,12 +79,12 @@ using namespace sysc;
 volatile std::array<bool, 2> tgc_init = {
     iss_factory::instance().register_creator("tgc5c|m_p|tcc",
                                              [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
                                                  auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::tgc5c>>(cc);
                                                  return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("tgc5c|mu_p|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-        auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+        auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
         auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::tgc5c>>(cc);
         return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
     })};
@@ -96,12 +96,12 @@ using namespace sysc;
 volatile std::array<bool, 2> tgc_init = {
     iss_factory::instance().register_creator("tgc5c|m_p|asmjit",
                                              [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
                                                  auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::tgc5c>>(cc);
                                                  return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("tgc5c|mu_p|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-        auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+        auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
         auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::tgc5c>>(cc);
         return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
     })};
diff --git a/src/sysc/sc_core_adapter.h b/src/sysc/sc_core_adapter.h
index c140cac..f60cac4 100644
--- a/src/sysc/sc_core_adapter.h
+++ b/src/sysc/sc_core_adapter.h
@@ -163,7 +163,7 @@ public:
     }
 
 private:
-    sysc::tgfs::core_complex_if* const owner;
+    sysc::tgfs::core_complex_if* const owner{nullptr};
     sc_core::sc_event wfi_evt;
     uint64_t hostvar{std::numeric_limits<uint64_t>::max()};
     unsigned to_host_wr_cnt = 0;

From de79adc50d0143349cfbd3d69306bf13ee8eb39b Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 12:37:57 +0200
Subject: [PATCH 080/100] updates debugger hook to stop before fetching
 instructions

this relates to https://github.com/Minres/DBT-RISE-RISCV/issues/8 :
Debugger loses control when trap vector fetch fails

and https://github.com/Minres/DBT-RISE-RISCV/issues/7 : Two debugger
single-steps are required at reset vector
---
 gen_input/templates/interp/CORENAME.cpp.gtl | 16 ++++++++++------
 src/iss/arch/riscv_hart_m_p.h               | 18 ++++++++++++------
 src/vm/interp/vm_tgc5c.cpp                  | 16 ++++++++++------
 3 files changed, 32 insertions(+), 18 deletions(-)

diff --git a/gen_input/templates/interp/CORENAME.cpp.gtl b/gen_input/templates/interp/CORENAME.cpp.gtl
index 1c45797..d2ebedd 100644
--- a/gen_input/templates/interp/CORENAME.cpp.gtl
+++ b/gen_input/templates/interp/CORENAME.cpp.gtl
@@ -257,10 +257,14 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
     while(!this->core.should_stop() &&
             !(is_icount_limit_enabled(cond) && icount >= count_limit) &&
             !(is_fcount_limit_enabled(cond) && fetch_count >= count_limit)){
-        fetch_count++;
+        if(this->debugging_enabled())
+            this->tgt_adapter->check_continue(*PC);
+        pc.val=*PC;
         if(fetch_ins(pc, data)!=iss::Ok){
-            this->do_sync(POST_SYNC, std::numeric_limits<unsigned>::max());
-            pc.val = super::core.enter_trap(std::numeric_limits<uint64_t>::max(), pc.val, 0);
+            if(this->sync_exec && PRE_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
+            process_spawn_blocks();
+            if(this->sync_exec && POST_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
+            pc.val = super::core.enter_trap(arch::traits<ARCH>::RV_CAUSE_FETCH_ACCESS<<16, pc.val, 0);
         } else {
             if (is_jump_to_self_enabled(cond) &&
                     (instr == 0x0000006f || (instr&0xffff)==0xa001)) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
@@ -311,11 +315,11 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 icount++;
                 instret++;
             }
-            cycle++;
-            pc.val=*NEXT_PC;
-            this->core.reg.PC = this->core.reg.NEXT_PC;
+            *PC = *NEXT_PC;
             this->core.reg.trap_state =  this->core.reg.pending_trap;
         }
+        fetch_count++;
+        cycle++;
     }
     return pc;
 }
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index bbd2b49..8b27dec 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -689,8 +689,10 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
                 }
                 return res;
             } catch(trap_access& ta) {
-                this->reg.trap_state = (1UL << 31) | ta.id;
-                fault_data = ta.addr;
+                if( (access & access_type::DEBUG) == 0) {
+                    this->reg.trap_state = (1UL << 31) | ta.id;
+                    fault_data = ta.addr;
+                }
                 return iss::Err;
             }
         } break;
@@ -717,8 +719,10 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
@@ -848,8 +852,10 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
diff --git a/src/vm/interp/vm_tgc5c.cpp b/src/vm/interp/vm_tgc5c.cpp
index 7cd10ad..7d4161a 100644
--- a/src/vm/interp/vm_tgc5c.cpp
+++ b/src/vm/interp/vm_tgc5c.cpp
@@ -333,10 +333,14 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
     while(!this->core.should_stop() &&
             !(is_icount_limit_enabled(cond) && icount >= count_limit) &&
             !(is_fcount_limit_enabled(cond) && fetch_count >= count_limit)){
-        fetch_count++;
+        if(this->debugging_enabled())
+            this->tgt_adapter->check_continue(*PC);
+        pc.val=*PC;
         if(fetch_ins(pc, data)!=iss::Ok){
-            this->do_sync(POST_SYNC, std::numeric_limits<unsigned>::max());
-            pc.val = super::core.enter_trap(std::numeric_limits<uint64_t>::max(), pc.val, 0);
+            if(this->sync_exec && PRE_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
+            process_spawn_blocks();
+            if(this->sync_exec && POST_SYNC) this->do_sync(PRE_SYNC, std::numeric_limits<unsigned>::max());
+            pc.val = super::core.enter_trap(arch::traits<ARCH>::RV_CAUSE_FETCH_ACCESS<<16, pc.val, 0);
         } else {
             if (is_jump_to_self_enabled(cond) &&
                     (instr == 0x0000006f || (instr&0xffff)==0xa001)) throw simulation_stopped(0); // 'J 0' or 'C.J 0'
@@ -2673,11 +2677,11 @@ typename vm_base<ARCH>::virt_addr_t vm_impl<ARCH>::execute_inst(finish_cond_e co
                 icount++;
                 instret++;
             }
-            cycle++;
-            pc.val=*NEXT_PC;
-            this->core.reg.PC = this->core.reg.NEXT_PC;
+            *PC = *NEXT_PC;
             this->core.reg.trap_state =  this->core.reg.pending_trap;
         }
+        fetch_count++;
+        cycle++;
     }
     return pc;
 }

From 6305efa7c2bb4177e0f438f2e209be82eed7f992 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 12:40:40 +0200
Subject: [PATCH 081/100] implements proper target XML generation incl. CSRs

---
 CMakeLists.txt                          |    1 +
 src/iss/debugger/csr_names.cpp          | 4108 +++++++++++++++++++++++
 src/iss/debugger/riscv_target_adapter.h |  256 +-
 3 files changed, 4228 insertions(+), 137 deletions(-)
 create mode 100644 src/iss/debugger/csr_names.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2a46f47..0d5bafc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,7 @@ set(LIB_SOURCES
     src/iss/arch/tgc5c.cpp
     src/vm/interp/vm_tgc5c.cpp
     src/vm/fp_functions.cpp
+    src/iss/debugger/csr_names.cpp
     src/iss/semihosting/semihosting.cpp
 )
 
diff --git a/src/iss/debugger/csr_names.cpp b/src/iss/debugger/csr_names.cpp
new file mode 100644
index 0000000..f1c35e2
--- /dev/null
+++ b/src/iss/debugger/csr_names.cpp
@@ -0,0 +1,4108 @@
+#include <array>
+// generated from:
+// * /scratch/eyck/workarea/Other/riscv-opcodes/csrs.csv
+// * /scratch/eyck/workarea/Other/riscv-opcodes/csrs32.csv
+namespace iss {
+namespace debugger {
+const std::array<char const* const, 4096> csr_names = {
+        "unknown", // 0
+         "fflags", // 1
+         "frm", // 2
+         "fcsr", // 3
+        "unknown", // 4
+        "unknown", // 5
+        "unknown", // 6
+         "utvt", // 7
+         "vstart", // 8
+         "vxsat", // 9
+         "vxrm", // 10
+        "unknown", // 11
+        "unknown", // 12
+        "unknown", // 13
+        "unknown", // 14
+         "vcsr", // 15
+        "unknown", // 16
+         "ssp", // 17
+        "unknown", // 18
+        "unknown", // 19
+        "unknown", // 20
+         "seed", // 21
+        "unknown", // 22
+         "jvt", // 23
+        "unknown", // 24
+        "unknown", // 25
+        "unknown", // 26
+        "unknown", // 27
+        "unknown", // 28
+        "unknown", // 29
+        "unknown", // 30
+        "unknown", // 31
+        "unknown", // 32
+        "unknown", // 33
+        "unknown", // 34
+        "unknown", // 35
+        "unknown", // 36
+        "unknown", // 37
+        "unknown", // 38
+        "unknown", // 39
+        "unknown", // 40
+        "unknown", // 41
+        "unknown", // 42
+        "unknown", // 43
+        "unknown", // 44
+        "unknown", // 45
+        "unknown", // 46
+        "unknown", // 47
+        "unknown", // 48
+        "unknown", // 49
+        "unknown", // 50
+        "unknown", // 51
+        "unknown", // 52
+        "unknown", // 53
+        "unknown", // 54
+        "unknown", // 55
+        "unknown", // 56
+        "unknown", // 57
+        "unknown", // 58
+        "unknown", // 59
+        "unknown", // 60
+        "unknown", // 61
+        "unknown", // 62
+        "unknown", // 63
+        "unknown", // 64
+        "unknown", // 65
+        "unknown", // 66
+        "unknown", // 67
+        "unknown", // 68
+         "unxti", // 69
+         "uintstatus", // 70
+        "unknown", // 71
+         "uscratchcsw", // 72
+         "uscratchcswl", // 73
+        "unknown", // 74
+        "unknown", // 75
+        "unknown", // 76
+        "unknown", // 77
+        "unknown", // 78
+        "unknown", // 79
+        "unknown", // 80
+        "unknown", // 81
+        "unknown", // 82
+        "unknown", // 83
+        "unknown", // 84
+        "unknown", // 85
+        "unknown", // 86
+        "unknown", // 87
+        "unknown", // 88
+        "unknown", // 89
+        "unknown", // 90
+        "unknown", // 91
+        "unknown", // 92
+        "unknown", // 93
+        "unknown", // 94
+        "unknown", // 95
+        "unknown", // 96
+        "unknown", // 97
+        "unknown", // 98
+        "unknown", // 99
+        "unknown", // 100
+        "unknown", // 101
+        "unknown", // 102
+        "unknown", // 103
+        "unknown", // 104
+        "unknown", // 105
+        "unknown", // 106
+        "unknown", // 107
+        "unknown", // 108
+        "unknown", // 109
+        "unknown", // 110
+        "unknown", // 111
+        "unknown", // 112
+        "unknown", // 113
+        "unknown", // 114
+        "unknown", // 115
+        "unknown", // 116
+        "unknown", // 117
+        "unknown", // 118
+        "unknown", // 119
+        "unknown", // 120
+        "unknown", // 121
+        "unknown", // 122
+        "unknown", // 123
+        "unknown", // 124
+        "unknown", // 125
+        "unknown", // 126
+        "unknown", // 127
+        "unknown", // 128
+        "unknown", // 129
+        "unknown", // 130
+        "unknown", // 131
+        "unknown", // 132
+        "unknown", // 133
+        "unknown", // 134
+        "unknown", // 135
+        "unknown", // 136
+        "unknown", // 137
+        "unknown", // 138
+        "unknown", // 139
+        "unknown", // 140
+        "unknown", // 141
+        "unknown", // 142
+        "unknown", // 143
+        "unknown", // 144
+        "unknown", // 145
+        "unknown", // 146
+        "unknown", // 147
+        "unknown", // 148
+        "unknown", // 149
+        "unknown", // 150
+        "unknown", // 151
+        "unknown", // 152
+        "unknown", // 153
+        "unknown", // 154
+        "unknown", // 155
+        "unknown", // 156
+        "unknown", // 157
+        "unknown", // 158
+        "unknown", // 159
+        "unknown", // 160
+        "unknown", // 161
+        "unknown", // 162
+        "unknown", // 163
+        "unknown", // 164
+        "unknown", // 165
+        "unknown", // 166
+        "unknown", // 167
+        "unknown", // 168
+        "unknown", // 169
+        "unknown", // 170
+        "unknown", // 171
+        "unknown", // 172
+        "unknown", // 173
+        "unknown", // 174
+        "unknown", // 175
+        "unknown", // 176
+        "unknown", // 177
+        "unknown", // 178
+        "unknown", // 179
+        "unknown", // 180
+        "unknown", // 181
+        "unknown", // 182
+        "unknown", // 183
+        "unknown", // 184
+        "unknown", // 185
+        "unknown", // 186
+        "unknown", // 187
+        "unknown", // 188
+        "unknown", // 189
+        "unknown", // 190
+        "unknown", // 191
+        "unknown", // 192
+        "unknown", // 193
+        "unknown", // 194
+        "unknown", // 195
+        "unknown", // 196
+        "unknown", // 197
+        "unknown", // 198
+        "unknown", // 199
+        "unknown", // 200
+        "unknown", // 201
+        "unknown", // 202
+        "unknown", // 203
+        "unknown", // 204
+        "unknown", // 205
+        "unknown", // 206
+        "unknown", // 207
+        "unknown", // 208
+        "unknown", // 209
+        "unknown", // 210
+        "unknown", // 211
+        "unknown", // 212
+        "unknown", // 213
+        "unknown", // 214
+        "unknown", // 215
+        "unknown", // 216
+        "unknown", // 217
+        "unknown", // 218
+        "unknown", // 219
+        "unknown", // 220
+        "unknown", // 221
+        "unknown", // 222
+        "unknown", // 223
+        "unknown", // 224
+        "unknown", // 225
+        "unknown", // 226
+        "unknown", // 227
+        "unknown", // 228
+        "unknown", // 229
+        "unknown", // 230
+        "unknown", // 231
+        "unknown", // 232
+        "unknown", // 233
+        "unknown", // 234
+        "unknown", // 235
+        "unknown", // 236
+        "unknown", // 237
+        "unknown", // 238
+        "unknown", // 239
+        "unknown", // 240
+        "unknown", // 241
+        "unknown", // 242
+        "unknown", // 243
+        "unknown", // 244
+        "unknown", // 245
+        "unknown", // 246
+        "unknown", // 247
+        "unknown", // 248
+        "unknown", // 249
+        "unknown", // 250
+        "unknown", // 251
+        "unknown", // 252
+        "unknown", // 253
+        "unknown", // 254
+        "unknown", // 255
+         "sstatus", // 256
+        "unknown", // 257
+         "sedeleg", // 258
+         "sideleg", // 259
+         "sie", // 260
+         "stvec", // 261
+         "scounteren", // 262
+         "stvt", // 263
+        "unknown", // 264
+        "unknown", // 265
+         "senvcfg", // 266
+        "unknown", // 267
+         "sstateen0", // 268
+         "sstateen1", // 269
+         "sstateen2", // 270
+         "sstateen3", // 271
+        "unknown", // 272
+        "unknown", // 273
+        "unknown", // 274
+        "unknown", // 275
+         "sieh", // 276
+        "unknown", // 277
+        "unknown", // 278
+        "unknown", // 279
+        "unknown", // 280
+        "unknown", // 281
+        "unknown", // 282
+        "unknown", // 283
+        "unknown", // 284
+        "unknown", // 285
+        "unknown", // 286
+        "unknown", // 287
+         "scountinhibit", // 288
+        "unknown", // 289
+        "unknown", // 290
+        "unknown", // 291
+        "unknown", // 292
+        "unknown", // 293
+        "unknown", // 294
+        "unknown", // 295
+        "unknown", // 296
+        "unknown", // 297
+        "unknown", // 298
+        "unknown", // 299
+        "unknown", // 300
+        "unknown", // 301
+        "unknown", // 302
+        "unknown", // 303
+        "unknown", // 304
+        "unknown", // 305
+        "unknown", // 306
+        "unknown", // 307
+        "unknown", // 308
+        "unknown", // 309
+        "unknown", // 310
+        "unknown", // 311
+        "unknown", // 312
+        "unknown", // 313
+        "unknown", // 314
+        "unknown", // 315
+        "unknown", // 316
+        "unknown", // 317
+        "unknown", // 318
+        "unknown", // 319
+         "sscratch", // 320
+         "sepc", // 321
+         "scause", // 322
+         "stval", // 323
+         "sip", // 324
+         "snxti", // 325
+         "sintstatus", // 326
+        "unknown", // 327
+         "sscratchcsw", // 328
+         "sscratchcswl", // 329
+        "unknown", // 330
+        "unknown", // 331
+        "unknown", // 332
+         "stimecmp", // 333
+         "sctrctl", // 334
+         "sctrstatus", // 335
+         "siselect", // 336
+         "sireg", // 337
+         "sireg2", // 338
+         "sireg3", // 339
+         "siph", // 340
+         "sireg4", // 341
+         "sireg5", // 342
+         "sireg6", // 343
+        "unknown", // 344
+        "unknown", // 345
+        "unknown", // 346
+        "unknown", // 347
+         "stopei", // 348
+         "stimecmph", // 349
+        "unknown", // 350
+         "sctrdepth", // 351
+        "unknown", // 352
+        "unknown", // 353
+        "unknown", // 354
+        "unknown", // 355
+        "unknown", // 356
+        "unknown", // 357
+        "unknown", // 358
+        "unknown", // 359
+        "unknown", // 360
+        "unknown", // 361
+        "unknown", // 362
+        "unknown", // 363
+        "unknown", // 364
+        "unknown", // 365
+        "unknown", // 366
+        "unknown", // 367
+        "unknown", // 368
+        "unknown", // 369
+        "unknown", // 370
+        "unknown", // 371
+        "unknown", // 372
+        "unknown", // 373
+        "unknown", // 374
+        "unknown", // 375
+        "unknown", // 376
+        "unknown", // 377
+        "unknown", // 378
+        "unknown", // 379
+        "unknown", // 380
+        "unknown", // 381
+        "unknown", // 382
+        "unknown", // 383
+         "satp", // 384
+         "srmcfg", // 385
+        "unknown", // 386
+        "unknown", // 387
+        "unknown", // 388
+        "unknown", // 389
+        "unknown", // 390
+        "unknown", // 391
+        "unknown", // 392
+        "unknown", // 393
+        "unknown", // 394
+        "unknown", // 395
+        "unknown", // 396
+        "unknown", // 397
+        "unknown", // 398
+        "unknown", // 399
+        "unknown", // 400
+        "unknown", // 401
+        "unknown", // 402
+        "unknown", // 403
+        "unknown", // 404
+        "unknown", // 405
+        "unknown", // 406
+        "unknown", // 407
+        "unknown", // 408
+        "unknown", // 409
+        "unknown", // 410
+        "unknown", // 411
+        "unknown", // 412
+        "unknown", // 413
+        "unknown", // 414
+        "unknown", // 415
+        "unknown", // 416
+        "unknown", // 417
+        "unknown", // 418
+        "unknown", // 419
+        "unknown", // 420
+        "unknown", // 421
+        "unknown", // 422
+        "unknown", // 423
+        "unknown", // 424
+        "unknown", // 425
+        "unknown", // 426
+        "unknown", // 427
+        "unknown", // 428
+        "unknown", // 429
+        "unknown", // 430
+        "unknown", // 431
+        "unknown", // 432
+        "unknown", // 433
+        "unknown", // 434
+        "unknown", // 435
+        "unknown", // 436
+        "unknown", // 437
+        "unknown", // 438
+        "unknown", // 439
+        "unknown", // 440
+        "unknown", // 441
+        "unknown", // 442
+        "unknown", // 443
+        "unknown", // 444
+        "unknown", // 445
+        "unknown", // 446
+        "unknown", // 447
+        "unknown", // 448
+        "unknown", // 449
+        "unknown", // 450
+        "unknown", // 451
+        "unknown", // 452
+        "unknown", // 453
+        "unknown", // 454
+        "unknown", // 455
+        "unknown", // 456
+        "unknown", // 457
+        "unknown", // 458
+        "unknown", // 459
+        "unknown", // 460
+        "unknown", // 461
+        "unknown", // 462
+        "unknown", // 463
+        "unknown", // 464
+        "unknown", // 465
+        "unknown", // 466
+        "unknown", // 467
+        "unknown", // 468
+        "unknown", // 469
+        "unknown", // 470
+        "unknown", // 471
+        "unknown", // 472
+        "unknown", // 473
+        "unknown", // 474
+        "unknown", // 475
+        "unknown", // 476
+        "unknown", // 477
+        "unknown", // 478
+        "unknown", // 479
+        "unknown", // 480
+        "unknown", // 481
+        "unknown", // 482
+        "unknown", // 483
+        "unknown", // 484
+        "unknown", // 485
+        "unknown", // 486
+        "unknown", // 487
+        "unknown", // 488
+        "unknown", // 489
+        "unknown", // 490
+        "unknown", // 491
+        "unknown", // 492
+        "unknown", // 493
+        "unknown", // 494
+        "unknown", // 495
+        "unknown", // 496
+        "unknown", // 497
+        "unknown", // 498
+        "unknown", // 499
+        "unknown", // 500
+        "unknown", // 501
+        "unknown", // 502
+        "unknown", // 503
+        "unknown", // 504
+        "unknown", // 505
+        "unknown", // 506
+        "unknown", // 507
+        "unknown", // 508
+        "unknown", // 509
+        "unknown", // 510
+        "unknown", // 511
+         "vsstatus", // 512
+        "unknown", // 513
+        "unknown", // 514
+        "unknown", // 515
+         "vsie", // 516
+         "vstvec", // 517
+        "unknown", // 518
+        "unknown", // 519
+        "unknown", // 520
+        "unknown", // 521
+        "unknown", // 522
+        "unknown", // 523
+        "unknown", // 524
+        "unknown", // 525
+        "unknown", // 526
+        "unknown", // 527
+        "unknown", // 528
+        "unknown", // 529
+        "unknown", // 530
+        "unknown", // 531
+         "vsieh", // 532
+        "unknown", // 533
+        "unknown", // 534
+        "unknown", // 535
+        "unknown", // 536
+        "unknown", // 537
+        "unknown", // 538
+        "unknown", // 539
+        "unknown", // 540
+        "unknown", // 541
+        "unknown", // 542
+        "unknown", // 543
+        "unknown", // 544
+        "unknown", // 545
+        "unknown", // 546
+        "unknown", // 547
+        "unknown", // 548
+        "unknown", // 549
+        "unknown", // 550
+        "unknown", // 551
+        "unknown", // 552
+        "unknown", // 553
+        "unknown", // 554
+        "unknown", // 555
+        "unknown", // 556
+        "unknown", // 557
+        "unknown", // 558
+        "unknown", // 559
+        "unknown", // 560
+        "unknown", // 561
+        "unknown", // 562
+        "unknown", // 563
+        "unknown", // 564
+        "unknown", // 565
+        "unknown", // 566
+        "unknown", // 567
+        "unknown", // 568
+        "unknown", // 569
+        "unknown", // 570
+        "unknown", // 571
+        "unknown", // 572
+        "unknown", // 573
+        "unknown", // 574
+        "unknown", // 575
+         "vsscratch", // 576
+         "vsepc", // 577
+         "vscause", // 578
+         "vstval", // 579
+         "vsip", // 580
+        "unknown", // 581
+        "unknown", // 582
+        "unknown", // 583
+        "unknown", // 584
+        "unknown", // 585
+        "unknown", // 586
+        "unknown", // 587
+        "unknown", // 588
+         "vstimecmp", // 589
+         "vsctrctl", // 590
+        "unknown", // 591
+         "vsiselect", // 592
+         "vsireg", // 593
+         "vsireg2", // 594
+         "vsireg3", // 595
+         "vsiph", // 596
+         "vsireg4", // 597
+         "vsireg5", // 598
+         "vsireg6", // 599
+        "unknown", // 600
+        "unknown", // 601
+        "unknown", // 602
+        "unknown", // 603
+         "vstopei", // 604
+         "vstimecmph", // 605
+        "unknown", // 606
+        "unknown", // 607
+        "unknown", // 608
+        "unknown", // 609
+        "unknown", // 610
+        "unknown", // 611
+        "unknown", // 612
+        "unknown", // 613
+        "unknown", // 614
+        "unknown", // 615
+        "unknown", // 616
+        "unknown", // 617
+        "unknown", // 618
+        "unknown", // 619
+        "unknown", // 620
+        "unknown", // 621
+        "unknown", // 622
+        "unknown", // 623
+        "unknown", // 624
+        "unknown", // 625
+        "unknown", // 626
+        "unknown", // 627
+        "unknown", // 628
+        "unknown", // 629
+        "unknown", // 630
+        "unknown", // 631
+        "unknown", // 632
+        "unknown", // 633
+        "unknown", // 634
+        "unknown", // 635
+        "unknown", // 636
+        "unknown", // 637
+        "unknown", // 638
+        "unknown", // 639
+         "vsatp", // 640
+        "unknown", // 641
+        "unknown", // 642
+        "unknown", // 643
+        "unknown", // 644
+        "unknown", // 645
+        "unknown", // 646
+        "unknown", // 647
+        "unknown", // 648
+        "unknown", // 649
+        "unknown", // 650
+        "unknown", // 651
+        "unknown", // 652
+        "unknown", // 653
+        "unknown", // 654
+        "unknown", // 655
+        "unknown", // 656
+        "unknown", // 657
+        "unknown", // 658
+        "unknown", // 659
+        "unknown", // 660
+        "unknown", // 661
+        "unknown", // 662
+        "unknown", // 663
+        "unknown", // 664
+        "unknown", // 665
+        "unknown", // 666
+        "unknown", // 667
+        "unknown", // 668
+        "unknown", // 669
+        "unknown", // 670
+        "unknown", // 671
+        "unknown", // 672
+        "unknown", // 673
+        "unknown", // 674
+        "unknown", // 675
+        "unknown", // 676
+        "unknown", // 677
+        "unknown", // 678
+        "unknown", // 679
+        "unknown", // 680
+        "unknown", // 681
+        "unknown", // 682
+        "unknown", // 683
+        "unknown", // 684
+        "unknown", // 685
+        "unknown", // 686
+        "unknown", // 687
+        "unknown", // 688
+        "unknown", // 689
+        "unknown", // 690
+        "unknown", // 691
+        "unknown", // 692
+        "unknown", // 693
+        "unknown", // 694
+        "unknown", // 695
+        "unknown", // 696
+        "unknown", // 697
+        "unknown", // 698
+        "unknown", // 699
+        "unknown", // 700
+        "unknown", // 701
+        "unknown", // 702
+        "unknown", // 703
+        "unknown", // 704
+        "unknown", // 705
+        "unknown", // 706
+        "unknown", // 707
+        "unknown", // 708
+        "unknown", // 709
+        "unknown", // 710
+        "unknown", // 711
+        "unknown", // 712
+        "unknown", // 713
+        "unknown", // 714
+        "unknown", // 715
+        "unknown", // 716
+        "unknown", // 717
+        "unknown", // 718
+        "unknown", // 719
+        "unknown", // 720
+        "unknown", // 721
+        "unknown", // 722
+        "unknown", // 723
+        "unknown", // 724
+        "unknown", // 725
+        "unknown", // 726
+        "unknown", // 727
+        "unknown", // 728
+        "unknown", // 729
+        "unknown", // 730
+        "unknown", // 731
+        "unknown", // 732
+        "unknown", // 733
+        "unknown", // 734
+        "unknown", // 735
+        "unknown", // 736
+        "unknown", // 737
+        "unknown", // 738
+        "unknown", // 739
+        "unknown", // 740
+        "unknown", // 741
+        "unknown", // 742
+        "unknown", // 743
+        "unknown", // 744
+        "unknown", // 745
+        "unknown", // 746
+        "unknown", // 747
+        "unknown", // 748
+        "unknown", // 749
+        "unknown", // 750
+        "unknown", // 751
+        "unknown", // 752
+        "unknown", // 753
+        "unknown", // 754
+        "unknown", // 755
+        "unknown", // 756
+        "unknown", // 757
+        "unknown", // 758
+        "unknown", // 759
+        "unknown", // 760
+        "unknown", // 761
+        "unknown", // 762
+        "unknown", // 763
+        "unknown", // 764
+        "unknown", // 765
+        "unknown", // 766
+        "unknown", // 767
+         "mstatus", // 768
+         "misa", // 769
+         "medeleg", // 770
+         "mideleg", // 771
+         "mie", // 772
+         "mtvec", // 773
+         "mcounteren", // 774
+         "mtvt", // 775
+         "mvien", // 776
+         "mvip", // 777
+         "menvcfg", // 778
+        "unknown", // 779
+         "mstateen0", // 780
+         "mstateen1", // 781
+         "mstateen2", // 782
+         "mstateen3", // 783
+         "mstatush", // 784
+        "unknown", // 785
+        "unknown", // 786
+         "midelegh", // 787
+         "mieh", // 788
+        "unknown", // 789
+        "unknown", // 790
+        "unknown", // 791
+         "mvienh", // 792
+         "mviph", // 793
+         "menvcfgh", // 794
+        "unknown", // 795
+         "mstateen0h", // 796
+         "mstateen1h", // 797
+         "mstateen2h", // 798
+         "mstateen3h", // 799
+         "mcountinhibit", // 800
+         "mcyclecfg", // 801
+         "minstretcfg", // 802
+         "mhpmevent3", // 803
+         "mhpmevent4", // 804
+         "mhpmevent5", // 805
+         "mhpmevent6", // 806
+         "mhpmevent7", // 807
+         "mhpmevent8", // 808
+         "mhpmevent9", // 809
+         "mhpmevent10", // 810
+         "mhpmevent11", // 811
+         "mhpmevent12", // 812
+         "mhpmevent13", // 813
+         "mhpmevent14", // 814
+         "mhpmevent15", // 815
+         "mhpmevent16", // 816
+         "mhpmevent17", // 817
+         "mhpmevent18", // 818
+         "mhpmevent19", // 819
+         "mhpmevent20", // 820
+         "mhpmevent21", // 821
+         "mhpmevent22", // 822
+         "mhpmevent23", // 823
+         "mhpmevent24", // 824
+         "mhpmevent25", // 825
+         "mhpmevent26", // 826
+         "mhpmevent27", // 827
+         "mhpmevent28", // 828
+         "mhpmevent29", // 829
+         "mhpmevent30", // 830
+         "mhpmevent31", // 831
+         "mscratch", // 832
+         "mepc", // 833
+         "mcause", // 834
+         "mtval", // 835
+         "mip", // 836
+         "mnxti", // 837
+         "mintstatus", // 838
+        "unknown", // 839
+         "mscratchcsw", // 840
+         "mscratchcswl", // 841
+         "mtinst", // 842
+         "mtval2", // 843
+        "unknown", // 844
+        "unknown", // 845
+         "mctrctl", // 846
+        "unknown", // 847
+         "miselect", // 848
+         "mireg", // 849
+         "mireg2", // 850
+         "mireg3", // 851
+         "miph", // 852
+         "mireg4", // 853
+         "mireg5", // 854
+         "mireg6", // 855
+        "unknown", // 856
+        "unknown", // 857
+        "unknown", // 858
+        "unknown", // 859
+         "mtopei", // 860
+        "unknown", // 861
+        "unknown", // 862
+        "unknown", // 863
+        "unknown", // 864
+        "unknown", // 865
+        "unknown", // 866
+        "unknown", // 867
+        "unknown", // 868
+        "unknown", // 869
+        "unknown", // 870
+        "unknown", // 871
+        "unknown", // 872
+        "unknown", // 873
+        "unknown", // 874
+        "unknown", // 875
+        "unknown", // 876
+        "unknown", // 877
+        "unknown", // 878
+        "unknown", // 879
+        "unknown", // 880
+        "unknown", // 881
+        "unknown", // 882
+        "unknown", // 883
+        "unknown", // 884
+        "unknown", // 885
+        "unknown", // 886
+        "unknown", // 887
+        "unknown", // 888
+        "unknown", // 889
+        "unknown", // 890
+        "unknown", // 891
+        "unknown", // 892
+        "unknown", // 893
+        "unknown", // 894
+        "unknown", // 895
+        "unknown", // 896
+        "unknown", // 897
+        "unknown", // 898
+        "unknown", // 899
+        "unknown", // 900
+        "unknown", // 901
+        "unknown", // 902
+        "unknown", // 903
+        "unknown", // 904
+        "unknown", // 905
+        "unknown", // 906
+        "unknown", // 907
+        "unknown", // 908
+        "unknown", // 909
+        "unknown", // 910
+        "unknown", // 911
+        "unknown", // 912
+        "unknown", // 913
+        "unknown", // 914
+        "unknown", // 915
+        "unknown", // 916
+        "unknown", // 917
+        "unknown", // 918
+        "unknown", // 919
+        "unknown", // 920
+        "unknown", // 921
+        "unknown", // 922
+        "unknown", // 923
+        "unknown", // 924
+        "unknown", // 925
+        "unknown", // 926
+        "unknown", // 927
+         "pmpcfg0", // 928
+         "pmpcfg1", // 929
+         "pmpcfg2", // 930
+         "pmpcfg3", // 931
+         "pmpcfg4", // 932
+         "pmpcfg5", // 933
+         "pmpcfg6", // 934
+         "pmpcfg7", // 935
+         "pmpcfg8", // 936
+         "pmpcfg9", // 937
+         "pmpcfg10", // 938
+         "pmpcfg11", // 939
+         "pmpcfg12", // 940
+         "pmpcfg13", // 941
+         "pmpcfg14", // 942
+         "pmpcfg15", // 943
+         "pmpaddr0", // 944
+         "pmpaddr1", // 945
+         "pmpaddr2", // 946
+         "pmpaddr3", // 947
+         "pmpaddr4", // 948
+         "pmpaddr5", // 949
+         "pmpaddr6", // 950
+         "pmpaddr7", // 951
+         "pmpaddr8", // 952
+         "pmpaddr9", // 953
+         "pmpaddr10", // 954
+         "pmpaddr11", // 955
+         "pmpaddr12", // 956
+         "pmpaddr13", // 957
+         "pmpaddr14", // 958
+         "pmpaddr15", // 959
+         "pmpaddr16", // 960
+         "pmpaddr17", // 961
+         "pmpaddr18", // 962
+         "pmpaddr19", // 963
+         "pmpaddr20", // 964
+         "pmpaddr21", // 965
+         "pmpaddr22", // 966
+         "pmpaddr23", // 967
+         "pmpaddr24", // 968
+         "pmpaddr25", // 969
+         "pmpaddr26", // 970
+         "pmpaddr27", // 971
+         "pmpaddr28", // 972
+         "pmpaddr29", // 973
+         "pmpaddr30", // 974
+         "pmpaddr31", // 975
+         "pmpaddr32", // 976
+         "pmpaddr33", // 977
+         "pmpaddr34", // 978
+         "pmpaddr35", // 979
+         "pmpaddr36", // 980
+         "pmpaddr37", // 981
+         "pmpaddr38", // 982
+         "pmpaddr39", // 983
+         "pmpaddr40", // 984
+         "pmpaddr41", // 985
+         "pmpaddr42", // 986
+         "pmpaddr43", // 987
+         "pmpaddr44", // 988
+         "pmpaddr45", // 989
+         "pmpaddr46", // 990
+         "pmpaddr47", // 991
+         "pmpaddr48", // 992
+         "pmpaddr49", // 993
+         "pmpaddr50", // 994
+         "pmpaddr51", // 995
+         "pmpaddr52", // 996
+         "pmpaddr53", // 997
+         "pmpaddr54", // 998
+         "pmpaddr55", // 999
+         "pmpaddr56", // 1000
+         "pmpaddr57", // 1001
+         "pmpaddr58", // 1002
+         "pmpaddr59", // 1003
+         "pmpaddr60", // 1004
+         "pmpaddr61", // 1005
+         "pmpaddr62", // 1006
+         "pmpaddr63", // 1007
+        "unknown", // 1008
+        "unknown", // 1009
+        "unknown", // 1010
+        "unknown", // 1011
+        "unknown", // 1012
+        "unknown", // 1013
+        "unknown", // 1014
+        "unknown", // 1015
+        "unknown", // 1016
+        "unknown", // 1017
+        "unknown", // 1018
+        "unknown", // 1019
+        "unknown", // 1020
+        "unknown", // 1021
+        "unknown", // 1022
+        "unknown", // 1023
+        "unknown", // 1024
+        "unknown", // 1025
+        "unknown", // 1026
+        "unknown", // 1027
+        "unknown", // 1028
+        "unknown", // 1029
+        "unknown", // 1030
+        "unknown", // 1031
+        "unknown", // 1032
+        "unknown", // 1033
+        "unknown", // 1034
+        "unknown", // 1035
+        "unknown", // 1036
+        "unknown", // 1037
+        "unknown", // 1038
+        "unknown", // 1039
+        "unknown", // 1040
+        "unknown", // 1041
+        "unknown", // 1042
+        "unknown", // 1043
+        "unknown", // 1044
+        "unknown", // 1045
+        "unknown", // 1046
+        "unknown", // 1047
+        "unknown", // 1048
+        "unknown", // 1049
+        "unknown", // 1050
+        "unknown", // 1051
+        "unknown", // 1052
+        "unknown", // 1053
+        "unknown", // 1054
+        "unknown", // 1055
+        "unknown", // 1056
+        "unknown", // 1057
+        "unknown", // 1058
+        "unknown", // 1059
+        "unknown", // 1060
+        "unknown", // 1061
+        "unknown", // 1062
+        "unknown", // 1063
+        "unknown", // 1064
+        "unknown", // 1065
+        "unknown", // 1066
+        "unknown", // 1067
+        "unknown", // 1068
+        "unknown", // 1069
+        "unknown", // 1070
+        "unknown", // 1071
+        "unknown", // 1072
+        "unknown", // 1073
+        "unknown", // 1074
+        "unknown", // 1075
+        "unknown", // 1076
+        "unknown", // 1077
+        "unknown", // 1078
+        "unknown", // 1079
+        "unknown", // 1080
+        "unknown", // 1081
+        "unknown", // 1082
+        "unknown", // 1083
+        "unknown", // 1084
+        "unknown", // 1085
+        "unknown", // 1086
+        "unknown", // 1087
+        "unknown", // 1088
+        "unknown", // 1089
+        "unknown", // 1090
+        "unknown", // 1091
+        "unknown", // 1092
+        "unknown", // 1093
+        "unknown", // 1094
+        "unknown", // 1095
+        "unknown", // 1096
+        "unknown", // 1097
+        "unknown", // 1098
+        "unknown", // 1099
+        "unknown", // 1100
+        "unknown", // 1101
+        "unknown", // 1102
+        "unknown", // 1103
+        "unknown", // 1104
+        "unknown", // 1105
+        "unknown", // 1106
+        "unknown", // 1107
+        "unknown", // 1108
+        "unknown", // 1109
+        "unknown", // 1110
+        "unknown", // 1111
+        "unknown", // 1112
+        "unknown", // 1113
+        "unknown", // 1114
+        "unknown", // 1115
+        "unknown", // 1116
+        "unknown", // 1117
+        "unknown", // 1118
+        "unknown", // 1119
+        "unknown", // 1120
+        "unknown", // 1121
+        "unknown", // 1122
+        "unknown", // 1123
+        "unknown", // 1124
+        "unknown", // 1125
+        "unknown", // 1126
+        "unknown", // 1127
+        "unknown", // 1128
+        "unknown", // 1129
+        "unknown", // 1130
+        "unknown", // 1131
+        "unknown", // 1132
+        "unknown", // 1133
+        "unknown", // 1134
+        "unknown", // 1135
+        "unknown", // 1136
+        "unknown", // 1137
+        "unknown", // 1138
+        "unknown", // 1139
+        "unknown", // 1140
+        "unknown", // 1141
+        "unknown", // 1142
+        "unknown", // 1143
+        "unknown", // 1144
+        "unknown", // 1145
+        "unknown", // 1146
+        "unknown", // 1147
+        "unknown", // 1148
+        "unknown", // 1149
+        "unknown", // 1150
+        "unknown", // 1151
+        "unknown", // 1152
+        "unknown", // 1153
+        "unknown", // 1154
+        "unknown", // 1155
+        "unknown", // 1156
+        "unknown", // 1157
+        "unknown", // 1158
+        "unknown", // 1159
+        "unknown", // 1160
+        "unknown", // 1161
+        "unknown", // 1162
+        "unknown", // 1163
+        "unknown", // 1164
+        "unknown", // 1165
+        "unknown", // 1166
+        "unknown", // 1167
+        "unknown", // 1168
+        "unknown", // 1169
+        "unknown", // 1170
+        "unknown", // 1171
+        "unknown", // 1172
+        "unknown", // 1173
+        "unknown", // 1174
+        "unknown", // 1175
+        "unknown", // 1176
+        "unknown", // 1177
+        "unknown", // 1178
+        "unknown", // 1179
+        "unknown", // 1180
+        "unknown", // 1181
+        "unknown", // 1182
+        "unknown", // 1183
+        "unknown", // 1184
+        "unknown", // 1185
+        "unknown", // 1186
+        "unknown", // 1187
+        "unknown", // 1188
+        "unknown", // 1189
+        "unknown", // 1190
+        "unknown", // 1191
+        "unknown", // 1192
+        "unknown", // 1193
+        "unknown", // 1194
+        "unknown", // 1195
+        "unknown", // 1196
+        "unknown", // 1197
+        "unknown", // 1198
+        "unknown", // 1199
+        "unknown", // 1200
+        "unknown", // 1201
+        "unknown", // 1202
+        "unknown", // 1203
+        "unknown", // 1204
+        "unknown", // 1205
+        "unknown", // 1206
+        "unknown", // 1207
+        "unknown", // 1208
+        "unknown", // 1209
+        "unknown", // 1210
+        "unknown", // 1211
+        "unknown", // 1212
+        "unknown", // 1213
+        "unknown", // 1214
+        "unknown", // 1215
+        "unknown", // 1216
+        "unknown", // 1217
+        "unknown", // 1218
+        "unknown", // 1219
+        "unknown", // 1220
+        "unknown", // 1221
+        "unknown", // 1222
+        "unknown", // 1223
+        "unknown", // 1224
+        "unknown", // 1225
+        "unknown", // 1226
+        "unknown", // 1227
+        "unknown", // 1228
+        "unknown", // 1229
+        "unknown", // 1230
+        "unknown", // 1231
+        "unknown", // 1232
+        "unknown", // 1233
+        "unknown", // 1234
+        "unknown", // 1235
+        "unknown", // 1236
+        "unknown", // 1237
+        "unknown", // 1238
+        "unknown", // 1239
+        "unknown", // 1240
+        "unknown", // 1241
+        "unknown", // 1242
+        "unknown", // 1243
+        "unknown", // 1244
+        "unknown", // 1245
+        "unknown", // 1246
+        "unknown", // 1247
+        "unknown", // 1248
+        "unknown", // 1249
+        "unknown", // 1250
+        "unknown", // 1251
+        "unknown", // 1252
+        "unknown", // 1253
+        "unknown", // 1254
+        "unknown", // 1255
+        "unknown", // 1256
+        "unknown", // 1257
+        "unknown", // 1258
+        "unknown", // 1259
+        "unknown", // 1260
+        "unknown", // 1261
+        "unknown", // 1262
+        "unknown", // 1263
+        "unknown", // 1264
+        "unknown", // 1265
+        "unknown", // 1266
+        "unknown", // 1267
+        "unknown", // 1268
+        "unknown", // 1269
+        "unknown", // 1270
+        "unknown", // 1271
+        "unknown", // 1272
+        "unknown", // 1273
+        "unknown", // 1274
+        "unknown", // 1275
+        "unknown", // 1276
+        "unknown", // 1277
+        "unknown", // 1278
+        "unknown", // 1279
+        "unknown", // 1280
+        "unknown", // 1281
+        "unknown", // 1282
+        "unknown", // 1283
+        "unknown", // 1284
+        "unknown", // 1285
+        "unknown", // 1286
+        "unknown", // 1287
+        "unknown", // 1288
+        "unknown", // 1289
+        "unknown", // 1290
+        "unknown", // 1291
+        "unknown", // 1292
+        "unknown", // 1293
+        "unknown", // 1294
+        "unknown", // 1295
+        "unknown", // 1296
+        "unknown", // 1297
+        "unknown", // 1298
+        "unknown", // 1299
+        "unknown", // 1300
+        "unknown", // 1301
+        "unknown", // 1302
+        "unknown", // 1303
+        "unknown", // 1304
+        "unknown", // 1305
+        "unknown", // 1306
+        "unknown", // 1307
+        "unknown", // 1308
+        "unknown", // 1309
+        "unknown", // 1310
+        "unknown", // 1311
+        "unknown", // 1312
+        "unknown", // 1313
+        "unknown", // 1314
+        "unknown", // 1315
+        "unknown", // 1316
+        "unknown", // 1317
+        "unknown", // 1318
+        "unknown", // 1319
+        "unknown", // 1320
+        "unknown", // 1321
+        "unknown", // 1322
+        "unknown", // 1323
+        "unknown", // 1324
+        "unknown", // 1325
+        "unknown", // 1326
+        "unknown", // 1327
+        "unknown", // 1328
+        "unknown", // 1329
+        "unknown", // 1330
+        "unknown", // 1331
+        "unknown", // 1332
+        "unknown", // 1333
+        "unknown", // 1334
+        "unknown", // 1335
+        "unknown", // 1336
+        "unknown", // 1337
+        "unknown", // 1338
+        "unknown", // 1339
+        "unknown", // 1340
+        "unknown", // 1341
+        "unknown", // 1342
+        "unknown", // 1343
+        "unknown", // 1344
+        "unknown", // 1345
+        "unknown", // 1346
+        "unknown", // 1347
+        "unknown", // 1348
+        "unknown", // 1349
+        "unknown", // 1350
+        "unknown", // 1351
+        "unknown", // 1352
+        "unknown", // 1353
+        "unknown", // 1354
+        "unknown", // 1355
+        "unknown", // 1356
+        "unknown", // 1357
+        "unknown", // 1358
+        "unknown", // 1359
+        "unknown", // 1360
+        "unknown", // 1361
+        "unknown", // 1362
+        "unknown", // 1363
+        "unknown", // 1364
+        "unknown", // 1365
+        "unknown", // 1366
+        "unknown", // 1367
+        "unknown", // 1368
+        "unknown", // 1369
+        "unknown", // 1370
+        "unknown", // 1371
+        "unknown", // 1372
+        "unknown", // 1373
+        "unknown", // 1374
+        "unknown", // 1375
+        "unknown", // 1376
+        "unknown", // 1377
+        "unknown", // 1378
+        "unknown", // 1379
+        "unknown", // 1380
+        "unknown", // 1381
+        "unknown", // 1382
+        "unknown", // 1383
+        "unknown", // 1384
+        "unknown", // 1385
+        "unknown", // 1386
+        "unknown", // 1387
+        "unknown", // 1388
+        "unknown", // 1389
+        "unknown", // 1390
+        "unknown", // 1391
+        "unknown", // 1392
+        "unknown", // 1393
+        "unknown", // 1394
+        "unknown", // 1395
+        "unknown", // 1396
+        "unknown", // 1397
+        "unknown", // 1398
+        "unknown", // 1399
+        "unknown", // 1400
+        "unknown", // 1401
+        "unknown", // 1402
+        "unknown", // 1403
+        "unknown", // 1404
+        "unknown", // 1405
+        "unknown", // 1406
+        "unknown", // 1407
+        "unknown", // 1408
+        "unknown", // 1409
+        "unknown", // 1410
+        "unknown", // 1411
+        "unknown", // 1412
+        "unknown", // 1413
+        "unknown", // 1414
+        "unknown", // 1415
+        "unknown", // 1416
+        "unknown", // 1417
+        "unknown", // 1418
+        "unknown", // 1419
+        "unknown", // 1420
+        "unknown", // 1421
+        "unknown", // 1422
+        "unknown", // 1423
+        "unknown", // 1424
+        "unknown", // 1425
+        "unknown", // 1426
+        "unknown", // 1427
+        "unknown", // 1428
+        "unknown", // 1429
+        "unknown", // 1430
+        "unknown", // 1431
+        "unknown", // 1432
+        "unknown", // 1433
+        "unknown", // 1434
+        "unknown", // 1435
+        "unknown", // 1436
+        "unknown", // 1437
+        "unknown", // 1438
+        "unknown", // 1439
+        "unknown", // 1440
+        "unknown", // 1441
+        "unknown", // 1442
+        "unknown", // 1443
+        "unknown", // 1444
+        "unknown", // 1445
+        "unknown", // 1446
+        "unknown", // 1447
+         "scontext", // 1448
+        "unknown", // 1449
+        "unknown", // 1450
+        "unknown", // 1451
+        "unknown", // 1452
+        "unknown", // 1453
+        "unknown", // 1454
+        "unknown", // 1455
+        "unknown", // 1456
+        "unknown", // 1457
+        "unknown", // 1458
+        "unknown", // 1459
+        "unknown", // 1460
+        "unknown", // 1461
+        "unknown", // 1462
+        "unknown", // 1463
+        "unknown", // 1464
+        "unknown", // 1465
+        "unknown", // 1466
+        "unknown", // 1467
+        "unknown", // 1468
+        "unknown", // 1469
+        "unknown", // 1470
+        "unknown", // 1471
+        "unknown", // 1472
+        "unknown", // 1473
+        "unknown", // 1474
+        "unknown", // 1475
+        "unknown", // 1476
+        "unknown", // 1477
+        "unknown", // 1478
+        "unknown", // 1479
+        "unknown", // 1480
+        "unknown", // 1481
+        "unknown", // 1482
+        "unknown", // 1483
+        "unknown", // 1484
+        "unknown", // 1485
+        "unknown", // 1486
+        "unknown", // 1487
+        "unknown", // 1488
+        "unknown", // 1489
+        "unknown", // 1490
+        "unknown", // 1491
+        "unknown", // 1492
+        "unknown", // 1493
+        "unknown", // 1494
+        "unknown", // 1495
+        "unknown", // 1496
+        "unknown", // 1497
+        "unknown", // 1498
+        "unknown", // 1499
+        "unknown", // 1500
+        "unknown", // 1501
+        "unknown", // 1502
+        "unknown", // 1503
+        "unknown", // 1504
+        "unknown", // 1505
+        "unknown", // 1506
+        "unknown", // 1507
+        "unknown", // 1508
+        "unknown", // 1509
+        "unknown", // 1510
+        "unknown", // 1511
+        "unknown", // 1512
+        "unknown", // 1513
+        "unknown", // 1514
+        "unknown", // 1515
+        "unknown", // 1516
+        "unknown", // 1517
+        "unknown", // 1518
+        "unknown", // 1519
+        "unknown", // 1520
+        "unknown", // 1521
+        "unknown", // 1522
+        "unknown", // 1523
+        "unknown", // 1524
+        "unknown", // 1525
+        "unknown", // 1526
+        "unknown", // 1527
+        "unknown", // 1528
+        "unknown", // 1529
+        "unknown", // 1530
+        "unknown", // 1531
+        "unknown", // 1532
+        "unknown", // 1533
+        "unknown", // 1534
+        "unknown", // 1535
+         "hstatus", // 1536
+        "unknown", // 1537
+         "hedeleg", // 1538
+         "hideleg", // 1539
+         "hie", // 1540
+         "htimedelta", // 1541
+         "hcounteren", // 1542
+         "hgeie", // 1543
+         "hvien", // 1544
+         "hvictl", // 1545
+         "henvcfg", // 1546
+        "unknown", // 1547
+         "hstateen0", // 1548
+         "hstateen1", // 1549
+         "hstateen2", // 1550
+         "hstateen3", // 1551
+        "unknown", // 1552
+        "unknown", // 1553
+        "unknown", // 1554
+         "hidelegh", // 1555
+        "unknown", // 1556
+         "htimedeltah", // 1557
+        "unknown", // 1558
+        "unknown", // 1559
+         "hvienh", // 1560
+        "unknown", // 1561
+         "henvcfgh", // 1562
+        "unknown", // 1563
+         "hstateen0h", // 1564
+         "hstateen1h", // 1565
+         "hstateen2h", // 1566
+         "hstateen3h", // 1567
+        "unknown", // 1568
+        "unknown", // 1569
+        "unknown", // 1570
+        "unknown", // 1571
+        "unknown", // 1572
+        "unknown", // 1573
+        "unknown", // 1574
+        "unknown", // 1575
+        "unknown", // 1576
+        "unknown", // 1577
+        "unknown", // 1578
+        "unknown", // 1579
+        "unknown", // 1580
+        "unknown", // 1581
+        "unknown", // 1582
+        "unknown", // 1583
+        "unknown", // 1584
+        "unknown", // 1585
+        "unknown", // 1586
+        "unknown", // 1587
+        "unknown", // 1588
+        "unknown", // 1589
+        "unknown", // 1590
+        "unknown", // 1591
+        "unknown", // 1592
+        "unknown", // 1593
+        "unknown", // 1594
+        "unknown", // 1595
+        "unknown", // 1596
+        "unknown", // 1597
+        "unknown", // 1598
+        "unknown", // 1599
+        "unknown", // 1600
+        "unknown", // 1601
+        "unknown", // 1602
+         "htval", // 1603
+         "hip", // 1604
+         "hvip", // 1605
+         "hviprio1", // 1606
+         "hviprio2", // 1607
+        "unknown", // 1608
+        "unknown", // 1609
+         "htinst", // 1610
+        "unknown", // 1611
+        "unknown", // 1612
+        "unknown", // 1613
+        "unknown", // 1614
+        "unknown", // 1615
+        "unknown", // 1616
+        "unknown", // 1617
+        "unknown", // 1618
+        "unknown", // 1619
+        "unknown", // 1620
+         "hviph", // 1621
+         "hviprio1h", // 1622
+         "hviprio2h", // 1623
+        "unknown", // 1624
+        "unknown", // 1625
+        "unknown", // 1626
+        "unknown", // 1627
+        "unknown", // 1628
+        "unknown", // 1629
+        "unknown", // 1630
+        "unknown", // 1631
+        "unknown", // 1632
+        "unknown", // 1633
+        "unknown", // 1634
+        "unknown", // 1635
+        "unknown", // 1636
+        "unknown", // 1637
+        "unknown", // 1638
+        "unknown", // 1639
+        "unknown", // 1640
+        "unknown", // 1641
+        "unknown", // 1642
+        "unknown", // 1643
+        "unknown", // 1644
+        "unknown", // 1645
+        "unknown", // 1646
+        "unknown", // 1647
+        "unknown", // 1648
+        "unknown", // 1649
+        "unknown", // 1650
+        "unknown", // 1651
+        "unknown", // 1652
+        "unknown", // 1653
+        "unknown", // 1654
+        "unknown", // 1655
+        "unknown", // 1656
+        "unknown", // 1657
+        "unknown", // 1658
+        "unknown", // 1659
+        "unknown", // 1660
+        "unknown", // 1661
+        "unknown", // 1662
+        "unknown", // 1663
+         "hgatp", // 1664
+        "unknown", // 1665
+        "unknown", // 1666
+        "unknown", // 1667
+        "unknown", // 1668
+        "unknown", // 1669
+        "unknown", // 1670
+        "unknown", // 1671
+        "unknown", // 1672
+        "unknown", // 1673
+        "unknown", // 1674
+        "unknown", // 1675
+        "unknown", // 1676
+        "unknown", // 1677
+        "unknown", // 1678
+        "unknown", // 1679
+        "unknown", // 1680
+        "unknown", // 1681
+        "unknown", // 1682
+        "unknown", // 1683
+        "unknown", // 1684
+        "unknown", // 1685
+        "unknown", // 1686
+        "unknown", // 1687
+        "unknown", // 1688
+        "unknown", // 1689
+        "unknown", // 1690
+        "unknown", // 1691
+        "unknown", // 1692
+        "unknown", // 1693
+        "unknown", // 1694
+        "unknown", // 1695
+        "unknown", // 1696
+        "unknown", // 1697
+        "unknown", // 1698
+        "unknown", // 1699
+        "unknown", // 1700
+        "unknown", // 1701
+        "unknown", // 1702
+        "unknown", // 1703
+         "hcontext", // 1704
+        "unknown", // 1705
+        "unknown", // 1706
+        "unknown", // 1707
+        "unknown", // 1708
+        "unknown", // 1709
+        "unknown", // 1710
+        "unknown", // 1711
+        "unknown", // 1712
+        "unknown", // 1713
+        "unknown", // 1714
+        "unknown", // 1715
+        "unknown", // 1716
+        "unknown", // 1717
+        "unknown", // 1718
+        "unknown", // 1719
+        "unknown", // 1720
+        "unknown", // 1721
+        "unknown", // 1722
+        "unknown", // 1723
+        "unknown", // 1724
+        "unknown", // 1725
+        "unknown", // 1726
+        "unknown", // 1727
+        "unknown", // 1728
+        "unknown", // 1729
+        "unknown", // 1730
+        "unknown", // 1731
+        "unknown", // 1732
+        "unknown", // 1733
+        "unknown", // 1734
+        "unknown", // 1735
+        "unknown", // 1736
+        "unknown", // 1737
+        "unknown", // 1738
+        "unknown", // 1739
+        "unknown", // 1740
+        "unknown", // 1741
+        "unknown", // 1742
+        "unknown", // 1743
+        "unknown", // 1744
+        "unknown", // 1745
+        "unknown", // 1746
+        "unknown", // 1747
+        "unknown", // 1748
+        "unknown", // 1749
+        "unknown", // 1750
+        "unknown", // 1751
+        "unknown", // 1752
+        "unknown", // 1753
+        "unknown", // 1754
+        "unknown", // 1755
+        "unknown", // 1756
+        "unknown", // 1757
+        "unknown", // 1758
+        "unknown", // 1759
+        "unknown", // 1760
+        "unknown", // 1761
+        "unknown", // 1762
+        "unknown", // 1763
+        "unknown", // 1764
+        "unknown", // 1765
+        "unknown", // 1766
+        "unknown", // 1767
+        "unknown", // 1768
+        "unknown", // 1769
+        "unknown", // 1770
+        "unknown", // 1771
+        "unknown", // 1772
+        "unknown", // 1773
+        "unknown", // 1774
+        "unknown", // 1775
+        "unknown", // 1776
+        "unknown", // 1777
+        "unknown", // 1778
+        "unknown", // 1779
+        "unknown", // 1780
+        "unknown", // 1781
+        "unknown", // 1782
+        "unknown", // 1783
+        "unknown", // 1784
+        "unknown", // 1785
+        "unknown", // 1786
+        "unknown", // 1787
+        "unknown", // 1788
+        "unknown", // 1789
+        "unknown", // 1790
+        "unknown", // 1791
+        "unknown", // 1792
+        "unknown", // 1793
+        "unknown", // 1794
+        "unknown", // 1795
+        "unknown", // 1796
+        "unknown", // 1797
+        "unknown", // 1798
+        "unknown", // 1799
+        "unknown", // 1800
+        "unknown", // 1801
+        "unknown", // 1802
+        "unknown", // 1803
+        "unknown", // 1804
+        "unknown", // 1805
+        "unknown", // 1806
+        "unknown", // 1807
+        "unknown", // 1808
+        "unknown", // 1809
+        "unknown", // 1810
+        "unknown", // 1811
+        "unknown", // 1812
+        "unknown", // 1813
+        "unknown", // 1814
+        "unknown", // 1815
+        "unknown", // 1816
+        "unknown", // 1817
+        "unknown", // 1818
+        "unknown", // 1819
+        "unknown", // 1820
+        "unknown", // 1821
+        "unknown", // 1822
+        "unknown", // 1823
+        "unknown", // 1824
+         "mcyclecfgh", // 1825
+         "minstretcfgh", // 1826
+         "mhpmevent3h", // 1827
+         "mhpmevent4h", // 1828
+         "mhpmevent5h", // 1829
+         "mhpmevent6h", // 1830
+         "mhpmevent7h", // 1831
+         "mhpmevent8h", // 1832
+         "mhpmevent9h", // 1833
+         "mhpmevent10h", // 1834
+         "mhpmevent11h", // 1835
+         "mhpmevent12h", // 1836
+         "mhpmevent13h", // 1837
+         "mhpmevent14h", // 1838
+         "mhpmevent15h", // 1839
+         "mhpmevent16h", // 1840
+         "mhpmevent17h", // 1841
+         "mhpmevent18h", // 1842
+         "mhpmevent19h", // 1843
+         "mhpmevent20h", // 1844
+         "mhpmevent21h", // 1845
+         "mhpmevent22h", // 1846
+         "mhpmevent23h", // 1847
+         "mhpmevent24h", // 1848
+         "mhpmevent25h", // 1849
+         "mhpmevent26h", // 1850
+         "mhpmevent27h", // 1851
+         "mhpmevent28h", // 1852
+         "mhpmevent29h", // 1853
+         "mhpmevent30h", // 1854
+         "mhpmevent31h", // 1855
+         "mnscratch", // 1856
+         "mnepc", // 1857
+         "mncause", // 1858
+        "unknown", // 1859
+         "mnstatus", // 1860
+        "unknown", // 1861
+        "unknown", // 1862
+         "mseccfg", // 1863
+        "unknown", // 1864
+        "unknown", // 1865
+        "unknown", // 1866
+        "unknown", // 1867
+        "unknown", // 1868
+        "unknown", // 1869
+        "unknown", // 1870
+        "unknown", // 1871
+        "unknown", // 1872
+        "unknown", // 1873
+        "unknown", // 1874
+        "unknown", // 1875
+        "unknown", // 1876
+        "unknown", // 1877
+        "unknown", // 1878
+         "mseccfgh", // 1879
+        "unknown", // 1880
+        "unknown", // 1881
+        "unknown", // 1882
+        "unknown", // 1883
+        "unknown", // 1884
+        "unknown", // 1885
+        "unknown", // 1886
+        "unknown", // 1887
+        "unknown", // 1888
+        "unknown", // 1889
+        "unknown", // 1890
+        "unknown", // 1891
+        "unknown", // 1892
+        "unknown", // 1893
+        "unknown", // 1894
+        "unknown", // 1895
+        "unknown", // 1896
+        "unknown", // 1897
+        "unknown", // 1898
+        "unknown", // 1899
+        "unknown", // 1900
+        "unknown", // 1901
+        "unknown", // 1902
+        "unknown", // 1903
+        "unknown", // 1904
+        "unknown", // 1905
+        "unknown", // 1906
+        "unknown", // 1907
+        "unknown", // 1908
+        "unknown", // 1909
+        "unknown", // 1910
+        "unknown", // 1911
+        "unknown", // 1912
+        "unknown", // 1913
+        "unknown", // 1914
+        "unknown", // 1915
+        "unknown", // 1916
+        "unknown", // 1917
+        "unknown", // 1918
+        "unknown", // 1919
+        "unknown", // 1920
+        "unknown", // 1921
+        "unknown", // 1922
+        "unknown", // 1923
+        "unknown", // 1924
+        "unknown", // 1925
+        "unknown", // 1926
+        "unknown", // 1927
+        "unknown", // 1928
+        "unknown", // 1929
+        "unknown", // 1930
+        "unknown", // 1931
+        "unknown", // 1932
+        "unknown", // 1933
+        "unknown", // 1934
+        "unknown", // 1935
+        "unknown", // 1936
+        "unknown", // 1937
+        "unknown", // 1938
+        "unknown", // 1939
+        "unknown", // 1940
+        "unknown", // 1941
+        "unknown", // 1942
+        "unknown", // 1943
+        "unknown", // 1944
+        "unknown", // 1945
+        "unknown", // 1946
+        "unknown", // 1947
+        "unknown", // 1948
+        "unknown", // 1949
+        "unknown", // 1950
+        "unknown", // 1951
+         "tselect", // 1952
+         "tdata1", // 1953
+         "tdata2", // 1954
+         "tdata3", // 1955
+         "tinfo", // 1956
+         "tcontrol", // 1957
+        "unknown", // 1958
+        "unknown", // 1959
+         "mcontext", // 1960
+        "unknown", // 1961
+         "mscontext", // 1962
+        "unknown", // 1963
+        "unknown", // 1964
+        "unknown", // 1965
+        "unknown", // 1966
+        "unknown", // 1967
+         "dcsr", // 1968
+         "dpc", // 1969
+         "dscratch0", // 1970
+         "dscratch1", // 1971
+        "unknown", // 1972
+        "unknown", // 1973
+        "unknown", // 1974
+        "unknown", // 1975
+        "unknown", // 1976
+        "unknown", // 1977
+        "unknown", // 1978
+        "unknown", // 1979
+        "unknown", // 1980
+        "unknown", // 1981
+        "unknown", // 1982
+        "unknown", // 1983
+        "unknown", // 1984
+        "unknown", // 1985
+        "unknown", // 1986
+        "unknown", // 1987
+        "unknown", // 1988
+        "unknown", // 1989
+        "unknown", // 1990
+        "unknown", // 1991
+        "unknown", // 1992
+        "unknown", // 1993
+        "unknown", // 1994
+        "unknown", // 1995
+        "unknown", // 1996
+        "unknown", // 1997
+        "unknown", // 1998
+        "unknown", // 1999
+        "unknown", // 2000
+        "unknown", // 2001
+        "unknown", // 2002
+        "unknown", // 2003
+        "unknown", // 2004
+        "unknown", // 2005
+        "unknown", // 2006
+        "unknown", // 2007
+        "unknown", // 2008
+        "unknown", // 2009
+        "unknown", // 2010
+        "unknown", // 2011
+        "unknown", // 2012
+        "unknown", // 2013
+        "unknown", // 2014
+        "unknown", // 2015
+        "unknown", // 2016
+        "unknown", // 2017
+        "unknown", // 2018
+        "unknown", // 2019
+        "unknown", // 2020
+        "unknown", // 2021
+        "unknown", // 2022
+        "unknown", // 2023
+        "unknown", // 2024
+        "unknown", // 2025
+        "unknown", // 2026
+        "unknown", // 2027
+        "unknown", // 2028
+        "unknown", // 2029
+        "unknown", // 2030
+        "unknown", // 2031
+        "unknown", // 2032
+        "unknown", // 2033
+        "unknown", // 2034
+        "unknown", // 2035
+        "unknown", // 2036
+        "unknown", // 2037
+        "unknown", // 2038
+        "unknown", // 2039
+        "unknown", // 2040
+        "unknown", // 2041
+        "unknown", // 2042
+        "unknown", // 2043
+        "unknown", // 2044
+        "unknown", // 2045
+        "unknown", // 2046
+        "unknown", // 2047
+        "unknown", // 2048
+        "unknown", // 2049
+        "unknown", // 2050
+        "unknown", // 2051
+        "unknown", // 2052
+        "unknown", // 2053
+        "unknown", // 2054
+        "unknown", // 2055
+        "unknown", // 2056
+        "unknown", // 2057
+        "unknown", // 2058
+        "unknown", // 2059
+        "unknown", // 2060
+        "unknown", // 2061
+        "unknown", // 2062
+        "unknown", // 2063
+        "unknown", // 2064
+        "unknown", // 2065
+        "unknown", // 2066
+        "unknown", // 2067
+        "unknown", // 2068
+        "unknown", // 2069
+        "unknown", // 2070
+        "unknown", // 2071
+        "unknown", // 2072
+        "unknown", // 2073
+        "unknown", // 2074
+        "unknown", // 2075
+        "unknown", // 2076
+        "unknown", // 2077
+        "unknown", // 2078
+        "unknown", // 2079
+        "unknown", // 2080
+        "unknown", // 2081
+        "unknown", // 2082
+        "unknown", // 2083
+        "unknown", // 2084
+        "unknown", // 2085
+        "unknown", // 2086
+        "unknown", // 2087
+        "unknown", // 2088
+        "unknown", // 2089
+        "unknown", // 2090
+        "unknown", // 2091
+        "unknown", // 2092
+        "unknown", // 2093
+        "unknown", // 2094
+        "unknown", // 2095
+        "unknown", // 2096
+        "unknown", // 2097
+        "unknown", // 2098
+        "unknown", // 2099
+        "unknown", // 2100
+        "unknown", // 2101
+        "unknown", // 2102
+        "unknown", // 2103
+        "unknown", // 2104
+        "unknown", // 2105
+        "unknown", // 2106
+        "unknown", // 2107
+        "unknown", // 2108
+        "unknown", // 2109
+        "unknown", // 2110
+        "unknown", // 2111
+        "unknown", // 2112
+        "unknown", // 2113
+        "unknown", // 2114
+        "unknown", // 2115
+        "unknown", // 2116
+        "unknown", // 2117
+        "unknown", // 2118
+        "unknown", // 2119
+        "unknown", // 2120
+        "unknown", // 2121
+        "unknown", // 2122
+        "unknown", // 2123
+        "unknown", // 2124
+        "unknown", // 2125
+        "unknown", // 2126
+        "unknown", // 2127
+        "unknown", // 2128
+        "unknown", // 2129
+        "unknown", // 2130
+        "unknown", // 2131
+        "unknown", // 2132
+        "unknown", // 2133
+        "unknown", // 2134
+        "unknown", // 2135
+        "unknown", // 2136
+        "unknown", // 2137
+        "unknown", // 2138
+        "unknown", // 2139
+        "unknown", // 2140
+        "unknown", // 2141
+        "unknown", // 2142
+        "unknown", // 2143
+        "unknown", // 2144
+        "unknown", // 2145
+        "unknown", // 2146
+        "unknown", // 2147
+        "unknown", // 2148
+        "unknown", // 2149
+        "unknown", // 2150
+        "unknown", // 2151
+        "unknown", // 2152
+        "unknown", // 2153
+        "unknown", // 2154
+        "unknown", // 2155
+        "unknown", // 2156
+        "unknown", // 2157
+        "unknown", // 2158
+        "unknown", // 2159
+        "unknown", // 2160
+        "unknown", // 2161
+        "unknown", // 2162
+        "unknown", // 2163
+        "unknown", // 2164
+        "unknown", // 2165
+        "unknown", // 2166
+        "unknown", // 2167
+        "unknown", // 2168
+        "unknown", // 2169
+        "unknown", // 2170
+        "unknown", // 2171
+        "unknown", // 2172
+        "unknown", // 2173
+        "unknown", // 2174
+        "unknown", // 2175
+        "unknown", // 2176
+        "unknown", // 2177
+        "unknown", // 2178
+        "unknown", // 2179
+        "unknown", // 2180
+        "unknown", // 2181
+        "unknown", // 2182
+        "unknown", // 2183
+        "unknown", // 2184
+        "unknown", // 2185
+        "unknown", // 2186
+        "unknown", // 2187
+        "unknown", // 2188
+        "unknown", // 2189
+        "unknown", // 2190
+        "unknown", // 2191
+        "unknown", // 2192
+        "unknown", // 2193
+        "unknown", // 2194
+        "unknown", // 2195
+        "unknown", // 2196
+        "unknown", // 2197
+        "unknown", // 2198
+        "unknown", // 2199
+        "unknown", // 2200
+        "unknown", // 2201
+        "unknown", // 2202
+        "unknown", // 2203
+        "unknown", // 2204
+        "unknown", // 2205
+        "unknown", // 2206
+        "unknown", // 2207
+        "unknown", // 2208
+        "unknown", // 2209
+        "unknown", // 2210
+        "unknown", // 2211
+        "unknown", // 2212
+        "unknown", // 2213
+        "unknown", // 2214
+        "unknown", // 2215
+        "unknown", // 2216
+        "unknown", // 2217
+        "unknown", // 2218
+        "unknown", // 2219
+        "unknown", // 2220
+        "unknown", // 2221
+        "unknown", // 2222
+        "unknown", // 2223
+        "unknown", // 2224
+        "unknown", // 2225
+        "unknown", // 2226
+        "unknown", // 2227
+        "unknown", // 2228
+        "unknown", // 2229
+        "unknown", // 2230
+        "unknown", // 2231
+        "unknown", // 2232
+        "unknown", // 2233
+        "unknown", // 2234
+        "unknown", // 2235
+        "unknown", // 2236
+        "unknown", // 2237
+        "unknown", // 2238
+        "unknown", // 2239
+        "unknown", // 2240
+        "unknown", // 2241
+        "unknown", // 2242
+        "unknown", // 2243
+        "unknown", // 2244
+        "unknown", // 2245
+        "unknown", // 2246
+        "unknown", // 2247
+        "unknown", // 2248
+        "unknown", // 2249
+        "unknown", // 2250
+        "unknown", // 2251
+        "unknown", // 2252
+        "unknown", // 2253
+        "unknown", // 2254
+        "unknown", // 2255
+        "unknown", // 2256
+        "unknown", // 2257
+        "unknown", // 2258
+        "unknown", // 2259
+        "unknown", // 2260
+        "unknown", // 2261
+        "unknown", // 2262
+        "unknown", // 2263
+        "unknown", // 2264
+        "unknown", // 2265
+        "unknown", // 2266
+        "unknown", // 2267
+        "unknown", // 2268
+        "unknown", // 2269
+        "unknown", // 2270
+        "unknown", // 2271
+        "unknown", // 2272
+        "unknown", // 2273
+        "unknown", // 2274
+        "unknown", // 2275
+        "unknown", // 2276
+        "unknown", // 2277
+        "unknown", // 2278
+        "unknown", // 2279
+        "unknown", // 2280
+        "unknown", // 2281
+        "unknown", // 2282
+        "unknown", // 2283
+        "unknown", // 2284
+        "unknown", // 2285
+        "unknown", // 2286
+        "unknown", // 2287
+        "unknown", // 2288
+        "unknown", // 2289
+        "unknown", // 2290
+        "unknown", // 2291
+        "unknown", // 2292
+        "unknown", // 2293
+        "unknown", // 2294
+        "unknown", // 2295
+        "unknown", // 2296
+        "unknown", // 2297
+        "unknown", // 2298
+        "unknown", // 2299
+        "unknown", // 2300
+        "unknown", // 2301
+        "unknown", // 2302
+        "unknown", // 2303
+        "unknown", // 2304
+        "unknown", // 2305
+        "unknown", // 2306
+        "unknown", // 2307
+        "unknown", // 2308
+        "unknown", // 2309
+        "unknown", // 2310
+        "unknown", // 2311
+        "unknown", // 2312
+        "unknown", // 2313
+        "unknown", // 2314
+        "unknown", // 2315
+        "unknown", // 2316
+        "unknown", // 2317
+        "unknown", // 2318
+        "unknown", // 2319
+        "unknown", // 2320
+        "unknown", // 2321
+        "unknown", // 2322
+        "unknown", // 2323
+        "unknown", // 2324
+        "unknown", // 2325
+        "unknown", // 2326
+        "unknown", // 2327
+        "unknown", // 2328
+        "unknown", // 2329
+        "unknown", // 2330
+        "unknown", // 2331
+        "unknown", // 2332
+        "unknown", // 2333
+        "unknown", // 2334
+        "unknown", // 2335
+        "unknown", // 2336
+        "unknown", // 2337
+        "unknown", // 2338
+        "unknown", // 2339
+        "unknown", // 2340
+        "unknown", // 2341
+        "unknown", // 2342
+        "unknown", // 2343
+        "unknown", // 2344
+        "unknown", // 2345
+        "unknown", // 2346
+        "unknown", // 2347
+        "unknown", // 2348
+        "unknown", // 2349
+        "unknown", // 2350
+        "unknown", // 2351
+        "unknown", // 2352
+        "unknown", // 2353
+        "unknown", // 2354
+        "unknown", // 2355
+        "unknown", // 2356
+        "unknown", // 2357
+        "unknown", // 2358
+        "unknown", // 2359
+        "unknown", // 2360
+        "unknown", // 2361
+        "unknown", // 2362
+        "unknown", // 2363
+        "unknown", // 2364
+        "unknown", // 2365
+        "unknown", // 2366
+        "unknown", // 2367
+        "unknown", // 2368
+        "unknown", // 2369
+        "unknown", // 2370
+        "unknown", // 2371
+        "unknown", // 2372
+        "unknown", // 2373
+        "unknown", // 2374
+        "unknown", // 2375
+        "unknown", // 2376
+        "unknown", // 2377
+        "unknown", // 2378
+        "unknown", // 2379
+        "unknown", // 2380
+        "unknown", // 2381
+        "unknown", // 2382
+        "unknown", // 2383
+        "unknown", // 2384
+        "unknown", // 2385
+        "unknown", // 2386
+        "unknown", // 2387
+        "unknown", // 2388
+        "unknown", // 2389
+        "unknown", // 2390
+        "unknown", // 2391
+        "unknown", // 2392
+        "unknown", // 2393
+        "unknown", // 2394
+        "unknown", // 2395
+        "unknown", // 2396
+        "unknown", // 2397
+        "unknown", // 2398
+        "unknown", // 2399
+        "unknown", // 2400
+        "unknown", // 2401
+        "unknown", // 2402
+        "unknown", // 2403
+        "unknown", // 2404
+        "unknown", // 2405
+        "unknown", // 2406
+        "unknown", // 2407
+        "unknown", // 2408
+        "unknown", // 2409
+        "unknown", // 2410
+        "unknown", // 2411
+        "unknown", // 2412
+        "unknown", // 2413
+        "unknown", // 2414
+        "unknown", // 2415
+        "unknown", // 2416
+        "unknown", // 2417
+        "unknown", // 2418
+        "unknown", // 2419
+        "unknown", // 2420
+        "unknown", // 2421
+        "unknown", // 2422
+        "unknown", // 2423
+        "unknown", // 2424
+        "unknown", // 2425
+        "unknown", // 2426
+        "unknown", // 2427
+        "unknown", // 2428
+        "unknown", // 2429
+        "unknown", // 2430
+        "unknown", // 2431
+        "unknown", // 2432
+        "unknown", // 2433
+        "unknown", // 2434
+        "unknown", // 2435
+        "unknown", // 2436
+        "unknown", // 2437
+        "unknown", // 2438
+        "unknown", // 2439
+        "unknown", // 2440
+        "unknown", // 2441
+        "unknown", // 2442
+        "unknown", // 2443
+        "unknown", // 2444
+        "unknown", // 2445
+        "unknown", // 2446
+        "unknown", // 2447
+        "unknown", // 2448
+        "unknown", // 2449
+        "unknown", // 2450
+        "unknown", // 2451
+        "unknown", // 2452
+        "unknown", // 2453
+        "unknown", // 2454
+        "unknown", // 2455
+        "unknown", // 2456
+        "unknown", // 2457
+        "unknown", // 2458
+        "unknown", // 2459
+        "unknown", // 2460
+        "unknown", // 2461
+        "unknown", // 2462
+        "unknown", // 2463
+        "unknown", // 2464
+        "unknown", // 2465
+        "unknown", // 2466
+        "unknown", // 2467
+        "unknown", // 2468
+        "unknown", // 2469
+        "unknown", // 2470
+        "unknown", // 2471
+        "unknown", // 2472
+        "unknown", // 2473
+        "unknown", // 2474
+        "unknown", // 2475
+        "unknown", // 2476
+        "unknown", // 2477
+        "unknown", // 2478
+        "unknown", // 2479
+        "unknown", // 2480
+        "unknown", // 2481
+        "unknown", // 2482
+        "unknown", // 2483
+        "unknown", // 2484
+        "unknown", // 2485
+        "unknown", // 2486
+        "unknown", // 2487
+        "unknown", // 2488
+        "unknown", // 2489
+        "unknown", // 2490
+        "unknown", // 2491
+        "unknown", // 2492
+        "unknown", // 2493
+        "unknown", // 2494
+        "unknown", // 2495
+        "unknown", // 2496
+        "unknown", // 2497
+        "unknown", // 2498
+        "unknown", // 2499
+        "unknown", // 2500
+        "unknown", // 2501
+        "unknown", // 2502
+        "unknown", // 2503
+        "unknown", // 2504
+        "unknown", // 2505
+        "unknown", // 2506
+        "unknown", // 2507
+        "unknown", // 2508
+        "unknown", // 2509
+        "unknown", // 2510
+        "unknown", // 2511
+        "unknown", // 2512
+        "unknown", // 2513
+        "unknown", // 2514
+        "unknown", // 2515
+        "unknown", // 2516
+        "unknown", // 2517
+        "unknown", // 2518
+        "unknown", // 2519
+        "unknown", // 2520
+        "unknown", // 2521
+        "unknown", // 2522
+        "unknown", // 2523
+        "unknown", // 2524
+        "unknown", // 2525
+        "unknown", // 2526
+        "unknown", // 2527
+        "unknown", // 2528
+        "unknown", // 2529
+        "unknown", // 2530
+        "unknown", // 2531
+        "unknown", // 2532
+        "unknown", // 2533
+        "unknown", // 2534
+        "unknown", // 2535
+        "unknown", // 2536
+        "unknown", // 2537
+        "unknown", // 2538
+        "unknown", // 2539
+        "unknown", // 2540
+        "unknown", // 2541
+        "unknown", // 2542
+        "unknown", // 2543
+        "unknown", // 2544
+        "unknown", // 2545
+        "unknown", // 2546
+        "unknown", // 2547
+        "unknown", // 2548
+        "unknown", // 2549
+        "unknown", // 2550
+        "unknown", // 2551
+        "unknown", // 2552
+        "unknown", // 2553
+        "unknown", // 2554
+        "unknown", // 2555
+        "unknown", // 2556
+        "unknown", // 2557
+        "unknown", // 2558
+        "unknown", // 2559
+        "unknown", // 2560
+        "unknown", // 2561
+        "unknown", // 2562
+        "unknown", // 2563
+        "unknown", // 2564
+        "unknown", // 2565
+        "unknown", // 2566
+        "unknown", // 2567
+        "unknown", // 2568
+        "unknown", // 2569
+        "unknown", // 2570
+        "unknown", // 2571
+        "unknown", // 2572
+        "unknown", // 2573
+        "unknown", // 2574
+        "unknown", // 2575
+        "unknown", // 2576
+        "unknown", // 2577
+        "unknown", // 2578
+        "unknown", // 2579
+        "unknown", // 2580
+        "unknown", // 2581
+        "unknown", // 2582
+        "unknown", // 2583
+        "unknown", // 2584
+        "unknown", // 2585
+        "unknown", // 2586
+        "unknown", // 2587
+        "unknown", // 2588
+        "unknown", // 2589
+        "unknown", // 2590
+        "unknown", // 2591
+        "unknown", // 2592
+        "unknown", // 2593
+        "unknown", // 2594
+        "unknown", // 2595
+        "unknown", // 2596
+        "unknown", // 2597
+        "unknown", // 2598
+        "unknown", // 2599
+        "unknown", // 2600
+        "unknown", // 2601
+        "unknown", // 2602
+        "unknown", // 2603
+        "unknown", // 2604
+        "unknown", // 2605
+        "unknown", // 2606
+        "unknown", // 2607
+        "unknown", // 2608
+        "unknown", // 2609
+        "unknown", // 2610
+        "unknown", // 2611
+        "unknown", // 2612
+        "unknown", // 2613
+        "unknown", // 2614
+        "unknown", // 2615
+        "unknown", // 2616
+        "unknown", // 2617
+        "unknown", // 2618
+        "unknown", // 2619
+        "unknown", // 2620
+        "unknown", // 2621
+        "unknown", // 2622
+        "unknown", // 2623
+        "unknown", // 2624
+        "unknown", // 2625
+        "unknown", // 2626
+        "unknown", // 2627
+        "unknown", // 2628
+        "unknown", // 2629
+        "unknown", // 2630
+        "unknown", // 2631
+        "unknown", // 2632
+        "unknown", // 2633
+        "unknown", // 2634
+        "unknown", // 2635
+        "unknown", // 2636
+        "unknown", // 2637
+        "unknown", // 2638
+        "unknown", // 2639
+        "unknown", // 2640
+        "unknown", // 2641
+        "unknown", // 2642
+        "unknown", // 2643
+        "unknown", // 2644
+        "unknown", // 2645
+        "unknown", // 2646
+        "unknown", // 2647
+        "unknown", // 2648
+        "unknown", // 2649
+        "unknown", // 2650
+        "unknown", // 2651
+        "unknown", // 2652
+        "unknown", // 2653
+        "unknown", // 2654
+        "unknown", // 2655
+        "unknown", // 2656
+        "unknown", // 2657
+        "unknown", // 2658
+        "unknown", // 2659
+        "unknown", // 2660
+        "unknown", // 2661
+        "unknown", // 2662
+        "unknown", // 2663
+        "unknown", // 2664
+        "unknown", // 2665
+        "unknown", // 2666
+        "unknown", // 2667
+        "unknown", // 2668
+        "unknown", // 2669
+        "unknown", // 2670
+        "unknown", // 2671
+        "unknown", // 2672
+        "unknown", // 2673
+        "unknown", // 2674
+        "unknown", // 2675
+        "unknown", // 2676
+        "unknown", // 2677
+        "unknown", // 2678
+        "unknown", // 2679
+        "unknown", // 2680
+        "unknown", // 2681
+        "unknown", // 2682
+        "unknown", // 2683
+        "unknown", // 2684
+        "unknown", // 2685
+        "unknown", // 2686
+        "unknown", // 2687
+        "unknown", // 2688
+        "unknown", // 2689
+        "unknown", // 2690
+        "unknown", // 2691
+        "unknown", // 2692
+        "unknown", // 2693
+        "unknown", // 2694
+        "unknown", // 2695
+        "unknown", // 2696
+        "unknown", // 2697
+        "unknown", // 2698
+        "unknown", // 2699
+        "unknown", // 2700
+        "unknown", // 2701
+        "unknown", // 2702
+        "unknown", // 2703
+        "unknown", // 2704
+        "unknown", // 2705
+        "unknown", // 2706
+        "unknown", // 2707
+        "unknown", // 2708
+        "unknown", // 2709
+        "unknown", // 2710
+        "unknown", // 2711
+        "unknown", // 2712
+        "unknown", // 2713
+        "unknown", // 2714
+        "unknown", // 2715
+        "unknown", // 2716
+        "unknown", // 2717
+        "unknown", // 2718
+        "unknown", // 2719
+        "unknown", // 2720
+        "unknown", // 2721
+        "unknown", // 2722
+        "unknown", // 2723
+        "unknown", // 2724
+        "unknown", // 2725
+        "unknown", // 2726
+        "unknown", // 2727
+        "unknown", // 2728
+        "unknown", // 2729
+        "unknown", // 2730
+        "unknown", // 2731
+        "unknown", // 2732
+        "unknown", // 2733
+        "unknown", // 2734
+        "unknown", // 2735
+        "unknown", // 2736
+        "unknown", // 2737
+        "unknown", // 2738
+        "unknown", // 2739
+        "unknown", // 2740
+        "unknown", // 2741
+        "unknown", // 2742
+        "unknown", // 2743
+        "unknown", // 2744
+        "unknown", // 2745
+        "unknown", // 2746
+        "unknown", // 2747
+        "unknown", // 2748
+        "unknown", // 2749
+        "unknown", // 2750
+        "unknown", // 2751
+        "unknown", // 2752
+        "unknown", // 2753
+        "unknown", // 2754
+        "unknown", // 2755
+        "unknown", // 2756
+        "unknown", // 2757
+        "unknown", // 2758
+        "unknown", // 2759
+        "unknown", // 2760
+        "unknown", // 2761
+        "unknown", // 2762
+        "unknown", // 2763
+        "unknown", // 2764
+        "unknown", // 2765
+        "unknown", // 2766
+        "unknown", // 2767
+        "unknown", // 2768
+        "unknown", // 2769
+        "unknown", // 2770
+        "unknown", // 2771
+        "unknown", // 2772
+        "unknown", // 2773
+        "unknown", // 2774
+        "unknown", // 2775
+        "unknown", // 2776
+        "unknown", // 2777
+        "unknown", // 2778
+        "unknown", // 2779
+        "unknown", // 2780
+        "unknown", // 2781
+        "unknown", // 2782
+        "unknown", // 2783
+        "unknown", // 2784
+        "unknown", // 2785
+        "unknown", // 2786
+        "unknown", // 2787
+        "unknown", // 2788
+        "unknown", // 2789
+        "unknown", // 2790
+        "unknown", // 2791
+        "unknown", // 2792
+        "unknown", // 2793
+        "unknown", // 2794
+        "unknown", // 2795
+        "unknown", // 2796
+        "unknown", // 2797
+        "unknown", // 2798
+        "unknown", // 2799
+        "unknown", // 2800
+        "unknown", // 2801
+        "unknown", // 2802
+        "unknown", // 2803
+        "unknown", // 2804
+        "unknown", // 2805
+        "unknown", // 2806
+        "unknown", // 2807
+        "unknown", // 2808
+        "unknown", // 2809
+        "unknown", // 2810
+        "unknown", // 2811
+        "unknown", // 2812
+        "unknown", // 2813
+        "unknown", // 2814
+        "unknown", // 2815
+         "mcycle", // 2816
+        "unknown", // 2817
+         "minstret", // 2818
+         "mhpmcounter3", // 2819
+         "mhpmcounter4", // 2820
+         "mhpmcounter5", // 2821
+         "mhpmcounter6", // 2822
+         "mhpmcounter7", // 2823
+         "mhpmcounter8", // 2824
+         "mhpmcounter9", // 2825
+         "mhpmcounter10", // 2826
+         "mhpmcounter11", // 2827
+         "mhpmcounter12", // 2828
+         "mhpmcounter13", // 2829
+         "mhpmcounter14", // 2830
+         "mhpmcounter15", // 2831
+         "mhpmcounter16", // 2832
+         "mhpmcounter17", // 2833
+         "mhpmcounter18", // 2834
+         "mhpmcounter19", // 2835
+         "mhpmcounter20", // 2836
+         "mhpmcounter21", // 2837
+         "mhpmcounter22", // 2838
+         "mhpmcounter23", // 2839
+         "mhpmcounter24", // 2840
+         "mhpmcounter25", // 2841
+         "mhpmcounter26", // 2842
+         "mhpmcounter27", // 2843
+         "mhpmcounter28", // 2844
+         "mhpmcounter29", // 2845
+         "mhpmcounter30", // 2846
+         "mhpmcounter31", // 2847
+        "unknown", // 2848
+        "unknown", // 2849
+        "unknown", // 2850
+        "unknown", // 2851
+        "unknown", // 2852
+        "unknown", // 2853
+        "unknown", // 2854
+        "unknown", // 2855
+        "unknown", // 2856
+        "unknown", // 2857
+        "unknown", // 2858
+        "unknown", // 2859
+        "unknown", // 2860
+        "unknown", // 2861
+        "unknown", // 2862
+        "unknown", // 2863
+        "unknown", // 2864
+        "unknown", // 2865
+        "unknown", // 2866
+        "unknown", // 2867
+        "unknown", // 2868
+        "unknown", // 2869
+        "unknown", // 2870
+        "unknown", // 2871
+        "unknown", // 2872
+        "unknown", // 2873
+        "unknown", // 2874
+        "unknown", // 2875
+        "unknown", // 2876
+        "unknown", // 2877
+        "unknown", // 2878
+        "unknown", // 2879
+        "unknown", // 2880
+        "unknown", // 2881
+        "unknown", // 2882
+        "unknown", // 2883
+        "unknown", // 2884
+        "unknown", // 2885
+        "unknown", // 2886
+        "unknown", // 2887
+        "unknown", // 2888
+        "unknown", // 2889
+        "unknown", // 2890
+        "unknown", // 2891
+        "unknown", // 2892
+        "unknown", // 2893
+        "unknown", // 2894
+        "unknown", // 2895
+        "unknown", // 2896
+        "unknown", // 2897
+        "unknown", // 2898
+        "unknown", // 2899
+        "unknown", // 2900
+        "unknown", // 2901
+        "unknown", // 2902
+        "unknown", // 2903
+        "unknown", // 2904
+        "unknown", // 2905
+        "unknown", // 2906
+        "unknown", // 2907
+        "unknown", // 2908
+        "unknown", // 2909
+        "unknown", // 2910
+        "unknown", // 2911
+        "unknown", // 2912
+        "unknown", // 2913
+        "unknown", // 2914
+        "unknown", // 2915
+        "unknown", // 2916
+        "unknown", // 2917
+        "unknown", // 2918
+        "unknown", // 2919
+        "unknown", // 2920
+        "unknown", // 2921
+        "unknown", // 2922
+        "unknown", // 2923
+        "unknown", // 2924
+        "unknown", // 2925
+        "unknown", // 2926
+        "unknown", // 2927
+        "unknown", // 2928
+        "unknown", // 2929
+        "unknown", // 2930
+        "unknown", // 2931
+        "unknown", // 2932
+        "unknown", // 2933
+        "unknown", // 2934
+        "unknown", // 2935
+        "unknown", // 2936
+        "unknown", // 2937
+        "unknown", // 2938
+        "unknown", // 2939
+        "unknown", // 2940
+        "unknown", // 2941
+        "unknown", // 2942
+        "unknown", // 2943
+         "mcycleh", // 2944
+        "unknown", // 2945
+         "minstreth", // 2946
+         "mhpmcounter3h", // 2947
+         "mhpmcounter4h", // 2948
+         "mhpmcounter5h", // 2949
+         "mhpmcounter6h", // 2950
+         "mhpmcounter7h", // 2951
+         "mhpmcounter8h", // 2952
+         "mhpmcounter9h", // 2953
+         "mhpmcounter10h", // 2954
+         "mhpmcounter11h", // 2955
+         "mhpmcounter12h", // 2956
+         "mhpmcounter13h", // 2957
+         "mhpmcounter14h", // 2958
+         "mhpmcounter15h", // 2959
+         "mhpmcounter16h", // 2960
+         "mhpmcounter17h", // 2961
+         "mhpmcounter18h", // 2962
+         "mhpmcounter19h", // 2963
+         "mhpmcounter20h", // 2964
+         "mhpmcounter21h", // 2965
+         "mhpmcounter22h", // 2966
+         "mhpmcounter23h", // 2967
+         "mhpmcounter24h", // 2968
+         "mhpmcounter25h", // 2969
+         "mhpmcounter26h", // 2970
+         "mhpmcounter27h", // 2971
+         "mhpmcounter28h", // 2972
+         "mhpmcounter29h", // 2973
+         "mhpmcounter30h", // 2974
+         "mhpmcounter31h", // 2975
+        "unknown", // 2976
+        "unknown", // 2977
+        "unknown", // 2978
+        "unknown", // 2979
+        "unknown", // 2980
+        "unknown", // 2981
+        "unknown", // 2982
+        "unknown", // 2983
+        "unknown", // 2984
+        "unknown", // 2985
+        "unknown", // 2986
+        "unknown", // 2987
+        "unknown", // 2988
+        "unknown", // 2989
+        "unknown", // 2990
+        "unknown", // 2991
+        "unknown", // 2992
+        "unknown", // 2993
+        "unknown", // 2994
+        "unknown", // 2995
+        "unknown", // 2996
+        "unknown", // 2997
+        "unknown", // 2998
+        "unknown", // 2999
+        "unknown", // 3000
+        "unknown", // 3001
+        "unknown", // 3002
+        "unknown", // 3003
+        "unknown", // 3004
+        "unknown", // 3005
+        "unknown", // 3006
+        "unknown", // 3007
+        "unknown", // 3008
+        "unknown", // 3009
+        "unknown", // 3010
+        "unknown", // 3011
+        "unknown", // 3012
+        "unknown", // 3013
+        "unknown", // 3014
+        "unknown", // 3015
+        "unknown", // 3016
+        "unknown", // 3017
+        "unknown", // 3018
+        "unknown", // 3019
+        "unknown", // 3020
+        "unknown", // 3021
+        "unknown", // 3022
+        "unknown", // 3023
+        "unknown", // 3024
+        "unknown", // 3025
+        "unknown", // 3026
+        "unknown", // 3027
+        "unknown", // 3028
+        "unknown", // 3029
+        "unknown", // 3030
+        "unknown", // 3031
+        "unknown", // 3032
+        "unknown", // 3033
+        "unknown", // 3034
+        "unknown", // 3035
+        "unknown", // 3036
+        "unknown", // 3037
+        "unknown", // 3038
+        "unknown", // 3039
+        "unknown", // 3040
+        "unknown", // 3041
+        "unknown", // 3042
+        "unknown", // 3043
+        "unknown", // 3044
+        "unknown", // 3045
+        "unknown", // 3046
+        "unknown", // 3047
+        "unknown", // 3048
+        "unknown", // 3049
+        "unknown", // 3050
+        "unknown", // 3051
+        "unknown", // 3052
+        "unknown", // 3053
+        "unknown", // 3054
+        "unknown", // 3055
+        "unknown", // 3056
+        "unknown", // 3057
+        "unknown", // 3058
+        "unknown", // 3059
+        "unknown", // 3060
+        "unknown", // 3061
+        "unknown", // 3062
+        "unknown", // 3063
+        "unknown", // 3064
+        "unknown", // 3065
+        "unknown", // 3066
+        "unknown", // 3067
+        "unknown", // 3068
+        "unknown", // 3069
+        "unknown", // 3070
+        "unknown", // 3071
+         "cycle", // 3072
+         "time", // 3073
+         "instret", // 3074
+         "hpmcounter3", // 3075
+         "hpmcounter4", // 3076
+         "hpmcounter5", // 3077
+         "hpmcounter6", // 3078
+         "hpmcounter7", // 3079
+         "hpmcounter8", // 3080
+         "hpmcounter9", // 3081
+         "hpmcounter10", // 3082
+         "hpmcounter11", // 3083
+         "hpmcounter12", // 3084
+         "hpmcounter13", // 3085
+         "hpmcounter14", // 3086
+         "hpmcounter15", // 3087
+         "hpmcounter16", // 3088
+         "hpmcounter17", // 3089
+         "hpmcounter18", // 3090
+         "hpmcounter19", // 3091
+         "hpmcounter20", // 3092
+         "hpmcounter21", // 3093
+         "hpmcounter22", // 3094
+         "hpmcounter23", // 3095
+         "hpmcounter24", // 3096
+         "hpmcounter25", // 3097
+         "hpmcounter26", // 3098
+         "hpmcounter27", // 3099
+         "hpmcounter28", // 3100
+         "hpmcounter29", // 3101
+         "hpmcounter30", // 3102
+         "hpmcounter31", // 3103
+         "vl", // 3104
+         "vtype", // 3105
+         "vlenb", // 3106
+        "unknown", // 3107
+        "unknown", // 3108
+        "unknown", // 3109
+        "unknown", // 3110
+        "unknown", // 3111
+        "unknown", // 3112
+        "unknown", // 3113
+        "unknown", // 3114
+        "unknown", // 3115
+        "unknown", // 3116
+        "unknown", // 3117
+        "unknown", // 3118
+        "unknown", // 3119
+        "unknown", // 3120
+        "unknown", // 3121
+        "unknown", // 3122
+        "unknown", // 3123
+        "unknown", // 3124
+        "unknown", // 3125
+        "unknown", // 3126
+        "unknown", // 3127
+        "unknown", // 3128
+        "unknown", // 3129
+        "unknown", // 3130
+        "unknown", // 3131
+        "unknown", // 3132
+        "unknown", // 3133
+        "unknown", // 3134
+        "unknown", // 3135
+        "unknown", // 3136
+        "unknown", // 3137
+        "unknown", // 3138
+        "unknown", // 3139
+        "unknown", // 3140
+        "unknown", // 3141
+        "unknown", // 3142
+        "unknown", // 3143
+        "unknown", // 3144
+        "unknown", // 3145
+        "unknown", // 3146
+        "unknown", // 3147
+        "unknown", // 3148
+        "unknown", // 3149
+        "unknown", // 3150
+        "unknown", // 3151
+        "unknown", // 3152
+        "unknown", // 3153
+        "unknown", // 3154
+        "unknown", // 3155
+        "unknown", // 3156
+        "unknown", // 3157
+        "unknown", // 3158
+        "unknown", // 3159
+        "unknown", // 3160
+        "unknown", // 3161
+        "unknown", // 3162
+        "unknown", // 3163
+        "unknown", // 3164
+        "unknown", // 3165
+        "unknown", // 3166
+        "unknown", // 3167
+        "unknown", // 3168
+        "unknown", // 3169
+        "unknown", // 3170
+        "unknown", // 3171
+        "unknown", // 3172
+        "unknown", // 3173
+        "unknown", // 3174
+        "unknown", // 3175
+        "unknown", // 3176
+        "unknown", // 3177
+        "unknown", // 3178
+        "unknown", // 3179
+        "unknown", // 3180
+        "unknown", // 3181
+        "unknown", // 3182
+        "unknown", // 3183
+        "unknown", // 3184
+        "unknown", // 3185
+        "unknown", // 3186
+        "unknown", // 3187
+        "unknown", // 3188
+        "unknown", // 3189
+        "unknown", // 3190
+        "unknown", // 3191
+        "unknown", // 3192
+        "unknown", // 3193
+        "unknown", // 3194
+        "unknown", // 3195
+        "unknown", // 3196
+        "unknown", // 3197
+        "unknown", // 3198
+        "unknown", // 3199
+         "cycleh", // 3200
+         "timeh", // 3201
+         "instreth", // 3202
+         "hpmcounter3h", // 3203
+         "hpmcounter4h", // 3204
+         "hpmcounter5h", // 3205
+         "hpmcounter6h", // 3206
+         "hpmcounter7h", // 3207
+         "hpmcounter8h", // 3208
+         "hpmcounter9h", // 3209
+         "hpmcounter10h", // 3210
+         "hpmcounter11h", // 3211
+         "hpmcounter12h", // 3212
+         "hpmcounter13h", // 3213
+         "hpmcounter14h", // 3214
+         "hpmcounter15h", // 3215
+         "hpmcounter16h", // 3216
+         "hpmcounter17h", // 3217
+         "hpmcounter18h", // 3218
+         "hpmcounter19h", // 3219
+         "hpmcounter20h", // 3220
+         "hpmcounter21h", // 3221
+         "hpmcounter22h", // 3222
+         "hpmcounter23h", // 3223
+         "hpmcounter24h", // 3224
+         "hpmcounter25h", // 3225
+         "hpmcounter26h", // 3226
+         "hpmcounter27h", // 3227
+         "hpmcounter28h", // 3228
+         "hpmcounter29h", // 3229
+         "hpmcounter30h", // 3230
+         "hpmcounter31h", // 3231
+        "unknown", // 3232
+        "unknown", // 3233
+        "unknown", // 3234
+        "unknown", // 3235
+        "unknown", // 3236
+        "unknown", // 3237
+        "unknown", // 3238
+        "unknown", // 3239
+        "unknown", // 3240
+        "unknown", // 3241
+        "unknown", // 3242
+        "unknown", // 3243
+        "unknown", // 3244
+        "unknown", // 3245
+        "unknown", // 3246
+        "unknown", // 3247
+        "unknown", // 3248
+        "unknown", // 3249
+        "unknown", // 3250
+        "unknown", // 3251
+        "unknown", // 3252
+        "unknown", // 3253
+        "unknown", // 3254
+        "unknown", // 3255
+        "unknown", // 3256
+        "unknown", // 3257
+        "unknown", // 3258
+        "unknown", // 3259
+        "unknown", // 3260
+        "unknown", // 3261
+        "unknown", // 3262
+        "unknown", // 3263
+        "unknown", // 3264
+        "unknown", // 3265
+        "unknown", // 3266
+        "unknown", // 3267
+        "unknown", // 3268
+        "unknown", // 3269
+        "unknown", // 3270
+        "unknown", // 3271
+        "unknown", // 3272
+        "unknown", // 3273
+        "unknown", // 3274
+        "unknown", // 3275
+        "unknown", // 3276
+        "unknown", // 3277
+        "unknown", // 3278
+        "unknown", // 3279
+        "unknown", // 3280
+        "unknown", // 3281
+        "unknown", // 3282
+        "unknown", // 3283
+        "unknown", // 3284
+        "unknown", // 3285
+        "unknown", // 3286
+        "unknown", // 3287
+        "unknown", // 3288
+        "unknown", // 3289
+        "unknown", // 3290
+        "unknown", // 3291
+        "unknown", // 3292
+        "unknown", // 3293
+        "unknown", // 3294
+        "unknown", // 3295
+        "unknown", // 3296
+        "unknown", // 3297
+        "unknown", // 3298
+        "unknown", // 3299
+        "unknown", // 3300
+        "unknown", // 3301
+        "unknown", // 3302
+        "unknown", // 3303
+        "unknown", // 3304
+        "unknown", // 3305
+        "unknown", // 3306
+        "unknown", // 3307
+        "unknown", // 3308
+        "unknown", // 3309
+        "unknown", // 3310
+        "unknown", // 3311
+        "unknown", // 3312
+        "unknown", // 3313
+        "unknown", // 3314
+        "unknown", // 3315
+        "unknown", // 3316
+        "unknown", // 3317
+        "unknown", // 3318
+        "unknown", // 3319
+        "unknown", // 3320
+        "unknown", // 3321
+        "unknown", // 3322
+        "unknown", // 3323
+        "unknown", // 3324
+        "unknown", // 3325
+        "unknown", // 3326
+        "unknown", // 3327
+        "unknown", // 3328
+        "unknown", // 3329
+        "unknown", // 3330
+        "unknown", // 3331
+        "unknown", // 3332
+        "unknown", // 3333
+        "unknown", // 3334
+        "unknown", // 3335
+        "unknown", // 3336
+        "unknown", // 3337
+        "unknown", // 3338
+        "unknown", // 3339
+        "unknown", // 3340
+        "unknown", // 3341
+        "unknown", // 3342
+        "unknown", // 3343
+        "unknown", // 3344
+        "unknown", // 3345
+        "unknown", // 3346
+        "unknown", // 3347
+        "unknown", // 3348
+        "unknown", // 3349
+        "unknown", // 3350
+        "unknown", // 3351
+        "unknown", // 3352
+        "unknown", // 3353
+        "unknown", // 3354
+        "unknown", // 3355
+        "unknown", // 3356
+        "unknown", // 3357
+        "unknown", // 3358
+        "unknown", // 3359
+        "unknown", // 3360
+        "unknown", // 3361
+        "unknown", // 3362
+        "unknown", // 3363
+        "unknown", // 3364
+        "unknown", // 3365
+        "unknown", // 3366
+        "unknown", // 3367
+        "unknown", // 3368
+        "unknown", // 3369
+        "unknown", // 3370
+        "unknown", // 3371
+        "unknown", // 3372
+        "unknown", // 3373
+        "unknown", // 3374
+        "unknown", // 3375
+        "unknown", // 3376
+        "unknown", // 3377
+        "unknown", // 3378
+        "unknown", // 3379
+        "unknown", // 3380
+        "unknown", // 3381
+        "unknown", // 3382
+        "unknown", // 3383
+        "unknown", // 3384
+        "unknown", // 3385
+        "unknown", // 3386
+        "unknown", // 3387
+        "unknown", // 3388
+        "unknown", // 3389
+        "unknown", // 3390
+        "unknown", // 3391
+        "unknown", // 3392
+        "unknown", // 3393
+        "unknown", // 3394
+        "unknown", // 3395
+        "unknown", // 3396
+        "unknown", // 3397
+        "unknown", // 3398
+        "unknown", // 3399
+        "unknown", // 3400
+        "unknown", // 3401
+        "unknown", // 3402
+        "unknown", // 3403
+        "unknown", // 3404
+        "unknown", // 3405
+        "unknown", // 3406
+        "unknown", // 3407
+        "unknown", // 3408
+        "unknown", // 3409
+        "unknown", // 3410
+        "unknown", // 3411
+        "unknown", // 3412
+        "unknown", // 3413
+        "unknown", // 3414
+        "unknown", // 3415
+        "unknown", // 3416
+        "unknown", // 3417
+        "unknown", // 3418
+        "unknown", // 3419
+        "unknown", // 3420
+        "unknown", // 3421
+        "unknown", // 3422
+        "unknown", // 3423
+        "unknown", // 3424
+        "unknown", // 3425
+        "unknown", // 3426
+        "unknown", // 3427
+        "unknown", // 3428
+        "unknown", // 3429
+        "unknown", // 3430
+        "unknown", // 3431
+        "unknown", // 3432
+        "unknown", // 3433
+        "unknown", // 3434
+        "unknown", // 3435
+        "unknown", // 3436
+        "unknown", // 3437
+        "unknown", // 3438
+        "unknown", // 3439
+        "unknown", // 3440
+        "unknown", // 3441
+        "unknown", // 3442
+        "unknown", // 3443
+        "unknown", // 3444
+        "unknown", // 3445
+        "unknown", // 3446
+        "unknown", // 3447
+        "unknown", // 3448
+        "unknown", // 3449
+        "unknown", // 3450
+        "unknown", // 3451
+        "unknown", // 3452
+        "unknown", // 3453
+        "unknown", // 3454
+        "unknown", // 3455
+        "unknown", // 3456
+        "unknown", // 3457
+        "unknown", // 3458
+        "unknown", // 3459
+        "unknown", // 3460
+        "unknown", // 3461
+        "unknown", // 3462
+        "unknown", // 3463
+        "unknown", // 3464
+        "unknown", // 3465
+        "unknown", // 3466
+        "unknown", // 3467
+        "unknown", // 3468
+        "unknown", // 3469
+        "unknown", // 3470
+        "unknown", // 3471
+        "unknown", // 3472
+        "unknown", // 3473
+        "unknown", // 3474
+        "unknown", // 3475
+        "unknown", // 3476
+        "unknown", // 3477
+        "unknown", // 3478
+        "unknown", // 3479
+        "unknown", // 3480
+        "unknown", // 3481
+        "unknown", // 3482
+        "unknown", // 3483
+        "unknown", // 3484
+        "unknown", // 3485
+        "unknown", // 3486
+        "unknown", // 3487
+         "scountovf", // 3488
+        "unknown", // 3489
+        "unknown", // 3490
+        "unknown", // 3491
+        "unknown", // 3492
+        "unknown", // 3493
+        "unknown", // 3494
+        "unknown", // 3495
+        "unknown", // 3496
+        "unknown", // 3497
+        "unknown", // 3498
+        "unknown", // 3499
+        "unknown", // 3500
+        "unknown", // 3501
+        "unknown", // 3502
+        "unknown", // 3503
+         "stopi", // 3504
+        "unknown", // 3505
+        "unknown", // 3506
+        "unknown", // 3507
+        "unknown", // 3508
+        "unknown", // 3509
+        "unknown", // 3510
+        "unknown", // 3511
+        "unknown", // 3512
+        "unknown", // 3513
+        "unknown", // 3514
+        "unknown", // 3515
+        "unknown", // 3516
+        "unknown", // 3517
+        "unknown", // 3518
+        "unknown", // 3519
+        "unknown", // 3520
+        "unknown", // 3521
+        "unknown", // 3522
+        "unknown", // 3523
+        "unknown", // 3524
+        "unknown", // 3525
+        "unknown", // 3526
+        "unknown", // 3527
+        "unknown", // 3528
+        "unknown", // 3529
+        "unknown", // 3530
+        "unknown", // 3531
+        "unknown", // 3532
+        "unknown", // 3533
+        "unknown", // 3534
+        "unknown", // 3535
+        "unknown", // 3536
+        "unknown", // 3537
+        "unknown", // 3538
+        "unknown", // 3539
+        "unknown", // 3540
+        "unknown", // 3541
+        "unknown", // 3542
+        "unknown", // 3543
+        "unknown", // 3544
+        "unknown", // 3545
+        "unknown", // 3546
+        "unknown", // 3547
+        "unknown", // 3548
+        "unknown", // 3549
+        "unknown", // 3550
+        "unknown", // 3551
+        "unknown", // 3552
+        "unknown", // 3553
+        "unknown", // 3554
+        "unknown", // 3555
+        "unknown", // 3556
+        "unknown", // 3557
+        "unknown", // 3558
+        "unknown", // 3559
+        "unknown", // 3560
+        "unknown", // 3561
+        "unknown", // 3562
+        "unknown", // 3563
+        "unknown", // 3564
+        "unknown", // 3565
+        "unknown", // 3566
+        "unknown", // 3567
+        "unknown", // 3568
+        "unknown", // 3569
+        "unknown", // 3570
+        "unknown", // 3571
+        "unknown", // 3572
+        "unknown", // 3573
+        "unknown", // 3574
+        "unknown", // 3575
+        "unknown", // 3576
+        "unknown", // 3577
+        "unknown", // 3578
+        "unknown", // 3579
+        "unknown", // 3580
+        "unknown", // 3581
+        "unknown", // 3582
+        "unknown", // 3583
+        "unknown", // 3584
+        "unknown", // 3585
+        "unknown", // 3586
+        "unknown", // 3587
+        "unknown", // 3588
+        "unknown", // 3589
+        "unknown", // 3590
+        "unknown", // 3591
+        "unknown", // 3592
+        "unknown", // 3593
+        "unknown", // 3594
+        "unknown", // 3595
+        "unknown", // 3596
+        "unknown", // 3597
+        "unknown", // 3598
+        "unknown", // 3599
+        "unknown", // 3600
+        "unknown", // 3601
+         "hgeip", // 3602
+        "unknown", // 3603
+        "unknown", // 3604
+        "unknown", // 3605
+        "unknown", // 3606
+        "unknown", // 3607
+        "unknown", // 3608
+        "unknown", // 3609
+        "unknown", // 3610
+        "unknown", // 3611
+        "unknown", // 3612
+        "unknown", // 3613
+        "unknown", // 3614
+        "unknown", // 3615
+        "unknown", // 3616
+        "unknown", // 3617
+        "unknown", // 3618
+        "unknown", // 3619
+        "unknown", // 3620
+        "unknown", // 3621
+        "unknown", // 3622
+        "unknown", // 3623
+        "unknown", // 3624
+        "unknown", // 3625
+        "unknown", // 3626
+        "unknown", // 3627
+        "unknown", // 3628
+        "unknown", // 3629
+        "unknown", // 3630
+        "unknown", // 3631
+        "unknown", // 3632
+        "unknown", // 3633
+        "unknown", // 3634
+        "unknown", // 3635
+        "unknown", // 3636
+        "unknown", // 3637
+        "unknown", // 3638
+        "unknown", // 3639
+        "unknown", // 3640
+        "unknown", // 3641
+        "unknown", // 3642
+        "unknown", // 3643
+        "unknown", // 3644
+        "unknown", // 3645
+        "unknown", // 3646
+        "unknown", // 3647
+        "unknown", // 3648
+        "unknown", // 3649
+        "unknown", // 3650
+        "unknown", // 3651
+        "unknown", // 3652
+        "unknown", // 3653
+        "unknown", // 3654
+        "unknown", // 3655
+        "unknown", // 3656
+        "unknown", // 3657
+        "unknown", // 3658
+        "unknown", // 3659
+        "unknown", // 3660
+        "unknown", // 3661
+        "unknown", // 3662
+        "unknown", // 3663
+        "unknown", // 3664
+        "unknown", // 3665
+        "unknown", // 3666
+        "unknown", // 3667
+        "unknown", // 3668
+        "unknown", // 3669
+        "unknown", // 3670
+        "unknown", // 3671
+        "unknown", // 3672
+        "unknown", // 3673
+        "unknown", // 3674
+        "unknown", // 3675
+        "unknown", // 3676
+        "unknown", // 3677
+        "unknown", // 3678
+        "unknown", // 3679
+        "unknown", // 3680
+        "unknown", // 3681
+        "unknown", // 3682
+        "unknown", // 3683
+        "unknown", // 3684
+        "unknown", // 3685
+        "unknown", // 3686
+        "unknown", // 3687
+        "unknown", // 3688
+        "unknown", // 3689
+        "unknown", // 3690
+        "unknown", // 3691
+        "unknown", // 3692
+        "unknown", // 3693
+        "unknown", // 3694
+        "unknown", // 3695
+        "unknown", // 3696
+        "unknown", // 3697
+        "unknown", // 3698
+        "unknown", // 3699
+        "unknown", // 3700
+        "unknown", // 3701
+        "unknown", // 3702
+        "unknown", // 3703
+        "unknown", // 3704
+        "unknown", // 3705
+        "unknown", // 3706
+        "unknown", // 3707
+        "unknown", // 3708
+        "unknown", // 3709
+        "unknown", // 3710
+        "unknown", // 3711
+        "unknown", // 3712
+        "unknown", // 3713
+        "unknown", // 3714
+        "unknown", // 3715
+        "unknown", // 3716
+        "unknown", // 3717
+        "unknown", // 3718
+        "unknown", // 3719
+        "unknown", // 3720
+        "unknown", // 3721
+        "unknown", // 3722
+        "unknown", // 3723
+        "unknown", // 3724
+        "unknown", // 3725
+        "unknown", // 3726
+        "unknown", // 3727
+        "unknown", // 3728
+        "unknown", // 3729
+        "unknown", // 3730
+        "unknown", // 3731
+        "unknown", // 3732
+        "unknown", // 3733
+        "unknown", // 3734
+        "unknown", // 3735
+        "unknown", // 3736
+        "unknown", // 3737
+        "unknown", // 3738
+        "unknown", // 3739
+        "unknown", // 3740
+        "unknown", // 3741
+        "unknown", // 3742
+        "unknown", // 3743
+        "unknown", // 3744
+        "unknown", // 3745
+        "unknown", // 3746
+        "unknown", // 3747
+        "unknown", // 3748
+        "unknown", // 3749
+        "unknown", // 3750
+        "unknown", // 3751
+        "unknown", // 3752
+        "unknown", // 3753
+        "unknown", // 3754
+        "unknown", // 3755
+        "unknown", // 3756
+        "unknown", // 3757
+        "unknown", // 3758
+        "unknown", // 3759
+         "vstopi", // 3760
+        "unknown", // 3761
+        "unknown", // 3762
+        "unknown", // 3763
+        "unknown", // 3764
+        "unknown", // 3765
+        "unknown", // 3766
+        "unknown", // 3767
+        "unknown", // 3768
+        "unknown", // 3769
+        "unknown", // 3770
+        "unknown", // 3771
+        "unknown", // 3772
+        "unknown", // 3773
+        "unknown", // 3774
+        "unknown", // 3775
+        "unknown", // 3776
+        "unknown", // 3777
+        "unknown", // 3778
+        "unknown", // 3779
+        "unknown", // 3780
+        "unknown", // 3781
+        "unknown", // 3782
+        "unknown", // 3783
+        "unknown", // 3784
+        "unknown", // 3785
+        "unknown", // 3786
+        "unknown", // 3787
+        "unknown", // 3788
+        "unknown", // 3789
+        "unknown", // 3790
+        "unknown", // 3791
+        "unknown", // 3792
+        "unknown", // 3793
+        "unknown", // 3794
+        "unknown", // 3795
+        "unknown", // 3796
+        "unknown", // 3797
+        "unknown", // 3798
+        "unknown", // 3799
+        "unknown", // 3800
+        "unknown", // 3801
+        "unknown", // 3802
+        "unknown", // 3803
+        "unknown", // 3804
+        "unknown", // 3805
+        "unknown", // 3806
+        "unknown", // 3807
+        "unknown", // 3808
+        "unknown", // 3809
+        "unknown", // 3810
+        "unknown", // 3811
+        "unknown", // 3812
+        "unknown", // 3813
+        "unknown", // 3814
+        "unknown", // 3815
+        "unknown", // 3816
+        "unknown", // 3817
+        "unknown", // 3818
+        "unknown", // 3819
+        "unknown", // 3820
+        "unknown", // 3821
+        "unknown", // 3822
+        "unknown", // 3823
+        "unknown", // 3824
+        "unknown", // 3825
+        "unknown", // 3826
+        "unknown", // 3827
+        "unknown", // 3828
+        "unknown", // 3829
+        "unknown", // 3830
+        "unknown", // 3831
+        "unknown", // 3832
+        "unknown", // 3833
+        "unknown", // 3834
+        "unknown", // 3835
+        "unknown", // 3836
+        "unknown", // 3837
+        "unknown", // 3838
+        "unknown", // 3839
+        "unknown", // 3840
+        "unknown", // 3841
+        "unknown", // 3842
+        "unknown", // 3843
+        "unknown", // 3844
+        "unknown", // 3845
+        "unknown", // 3846
+        "unknown", // 3847
+        "unknown", // 3848
+        "unknown", // 3849
+        "unknown", // 3850
+        "unknown", // 3851
+        "unknown", // 3852
+        "unknown", // 3853
+        "unknown", // 3854
+        "unknown", // 3855
+        "unknown", // 3856
+         "mvendorid", // 3857
+         "marchid", // 3858
+         "mimpid", // 3859
+         "mhartid", // 3860
+         "mconfigptr", // 3861
+        "unknown", // 3862
+        "unknown", // 3863
+        "unknown", // 3864
+        "unknown", // 3865
+        "unknown", // 3866
+        "unknown", // 3867
+        "unknown", // 3868
+        "unknown", // 3869
+        "unknown", // 3870
+        "unknown", // 3871
+        "unknown", // 3872
+        "unknown", // 3873
+        "unknown", // 3874
+        "unknown", // 3875
+        "unknown", // 3876
+        "unknown", // 3877
+        "unknown", // 3878
+        "unknown", // 3879
+        "unknown", // 3880
+        "unknown", // 3881
+        "unknown", // 3882
+        "unknown", // 3883
+        "unknown", // 3884
+        "unknown", // 3885
+        "unknown", // 3886
+        "unknown", // 3887
+        "unknown", // 3888
+        "unknown", // 3889
+        "unknown", // 3890
+        "unknown", // 3891
+        "unknown", // 3892
+        "unknown", // 3893
+        "unknown", // 3894
+        "unknown", // 3895
+        "unknown", // 3896
+        "unknown", // 3897
+        "unknown", // 3898
+        "unknown", // 3899
+        "unknown", // 3900
+        "unknown", // 3901
+        "unknown", // 3902
+        "unknown", // 3903
+        "unknown", // 3904
+        "unknown", // 3905
+        "unknown", // 3906
+        "unknown", // 3907
+        "unknown", // 3908
+        "unknown", // 3909
+        "unknown", // 3910
+        "unknown", // 3911
+        "unknown", // 3912
+        "unknown", // 3913
+        "unknown", // 3914
+        "unknown", // 3915
+        "unknown", // 3916
+        "unknown", // 3917
+        "unknown", // 3918
+        "unknown", // 3919
+        "unknown", // 3920
+        "unknown", // 3921
+        "unknown", // 3922
+        "unknown", // 3923
+        "unknown", // 3924
+        "unknown", // 3925
+        "unknown", // 3926
+        "unknown", // 3927
+        "unknown", // 3928
+        "unknown", // 3929
+        "unknown", // 3930
+        "unknown", // 3931
+        "unknown", // 3932
+        "unknown", // 3933
+        "unknown", // 3934
+        "unknown", // 3935
+        "unknown", // 3936
+        "unknown", // 3937
+        "unknown", // 3938
+        "unknown", // 3939
+        "unknown", // 3940
+        "unknown", // 3941
+        "unknown", // 3942
+        "unknown", // 3943
+        "unknown", // 3944
+        "unknown", // 3945
+        "unknown", // 3946
+        "unknown", // 3947
+        "unknown", // 3948
+        "unknown", // 3949
+        "unknown", // 3950
+        "unknown", // 3951
+        "unknown", // 3952
+        "unknown", // 3953
+        "unknown", // 3954
+        "unknown", // 3955
+        "unknown", // 3956
+        "unknown", // 3957
+        "unknown", // 3958
+        "unknown", // 3959
+        "unknown", // 3960
+        "unknown", // 3961
+        "unknown", // 3962
+        "unknown", // 3963
+        "unknown", // 3964
+        "unknown", // 3965
+        "unknown", // 3966
+        "unknown", // 3967
+        "unknown", // 3968
+        "unknown", // 3969
+        "unknown", // 3970
+        "unknown", // 3971
+        "unknown", // 3972
+        "unknown", // 3973
+        "unknown", // 3974
+        "unknown", // 3975
+        "unknown", // 3976
+        "unknown", // 3977
+        "unknown", // 3978
+        "unknown", // 3979
+        "unknown", // 3980
+        "unknown", // 3981
+        "unknown", // 3982
+        "unknown", // 3983
+        "unknown", // 3984
+        "unknown", // 3985
+        "unknown", // 3986
+        "unknown", // 3987
+        "unknown", // 3988
+        "unknown", // 3989
+        "unknown", // 3990
+        "unknown", // 3991
+        "unknown", // 3992
+        "unknown", // 3993
+        "unknown", // 3994
+        "unknown", // 3995
+        "unknown", // 3996
+        "unknown", // 3997
+        "unknown", // 3998
+        "unknown", // 3999
+        "unknown", // 4000
+        "unknown", // 4001
+        "unknown", // 4002
+        "unknown", // 4003
+        "unknown", // 4004
+        "unknown", // 4005
+        "unknown", // 4006
+        "unknown", // 4007
+        "unknown", // 4008
+        "unknown", // 4009
+        "unknown", // 4010
+        "unknown", // 4011
+        "unknown", // 4012
+        "unknown", // 4013
+        "unknown", // 4014
+        "unknown", // 4015
+         "mtopi", // 4016
+        "unknown", // 4017
+        "unknown", // 4018
+        "unknown", // 4019
+        "unknown", // 4020
+        "unknown", // 4021
+        "unknown", // 4022
+        "unknown", // 4023
+        "unknown", // 4024
+        "unknown", // 4025
+        "unknown", // 4026
+        "unknown", // 4027
+        "unknown", // 4028
+        "unknown", // 4029
+        "unknown", // 4030
+        "unknown", // 4031
+        "unknown", // 4032
+        "unknown", // 4033
+        "unknown", // 4034
+        "unknown", // 4035
+        "unknown", // 4036
+        "unknown", // 4037
+        "unknown", // 4038
+        "unknown", // 4039
+        "unknown", // 4040
+        "unknown", // 4041
+        "unknown", // 4042
+        "unknown", // 4043
+        "unknown", // 4044
+        "unknown", // 4045
+        "unknown", // 4046
+        "unknown", // 4047
+        "unknown", // 4048
+        "unknown", // 4049
+        "unknown", // 4050
+        "unknown", // 4051
+        "unknown", // 4052
+        "unknown", // 4053
+        "unknown", // 4054
+        "unknown", // 4055
+        "unknown", // 4056
+        "unknown", // 4057
+        "unknown", // 4058
+        "unknown", // 4059
+        "unknown", // 4060
+        "unknown", // 4061
+        "unknown", // 4062
+        "unknown", // 4063
+        "unknown", // 4064
+        "unknown", // 4065
+        "unknown", // 4066
+        "unknown", // 4067
+        "unknown", // 4068
+        "unknown", // 4069
+        "unknown", // 4070
+        "unknown", // 4071
+        "unknown", // 4072
+        "unknown", // 4073
+        "unknown", // 4074
+        "unknown", // 4075
+        "unknown", // 4076
+        "unknown", // 4077
+        "unknown", // 4078
+        "unknown", // 4079
+        "unknown", // 4080
+        "unknown", // 4081
+        "unknown", // 4082
+        "unknown", // 4083
+        "unknown", // 4084
+        "unknown", // 4085
+        "unknown", // 4086
+        "unknown", // 4087
+        "unknown", // 4088
+        "unknown", // 4089
+        "unknown", // 4090
+        "unknown", // 4091
+        "unknown", // 4092
+        "unknown", // 4093
+        "unknown", // 4094
+        "unknown", // 4095
+};
+char const* const get_csr_name(unsigned i) { return csr_names[i]; }
+
+}
+}
diff --git a/src/iss/debugger/riscv_target_adapter.h b/src/iss/debugger/riscv_target_adapter.h
index 7e18339..5ee48d2 100644
--- a/src/iss/debugger/riscv_target_adapter.h
+++ b/src/iss/debugger/riscv_target_adapter.h
@@ -30,8 +30,8 @@
  *
  *******************************************************************************/
 
-#ifndef _ISS_DEBUGGER_RISCV_TARGET_ADAPTER_H_
-#define _ISS_DEBUGGER_RISCV_TARGET_ADAPTER_H_
+#ifndef _ISS_ARCH_DEBUGGER_RISCV_TARGET_ADAPTER_H_
+#define _ISS_ARCH_DEBUGGER_RISCV_TARGET_ADAPTER_H_
 
 #include "iss/arch_if.h"
 #include <iss/arch/traits.h>
@@ -39,6 +39,8 @@
 #include <iss/iss.h>
 
 #include <array>
+#include <iostream>
+#include <fstream>
 #include <memory>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -48,6 +50,10 @@
 
 namespace iss {
 namespace debugger {
+
+char const* const get_csr_name(unsigned);
+constexpr auto csr_offset = 100U;
+
 using namespace iss::arch;
 using namespace iss::debugger;
 
@@ -103,7 +109,7 @@ public:
     status process_query(unsigned int& mask, const rp_thread_ref& arg, rp_thread_info& info) override;
 
     status thread_list_query(int first, const rp_thread_ref& arg, std::vector<rp_thread_ref>& result, size_t max_num, size_t& num,
-                             bool& done) override;
+            bool& done) override;
 
     status current_thread_query(rp_thread_ref& thread) override;
 
@@ -129,11 +135,21 @@ public:
 
 protected:
     static inline constexpr addr_t map_addr(const addr_t& i) { return i; }
-
+    std::string csr_xml;
     iss::arch_if* core;
     rp_thread_ref thread_idx;
 };
 
+template <typename ARCH>
+typename std::enable_if<iss::arch::traits<ARCH>::FLEN!=0, unsigned>::type get_f0_offset() {
+    return iss::arch::traits<ARCH>::F0;
+}
+
+template <typename ARCH>
+typename std::enable_if<iss::arch::traits<ARCH>::FLEN==0, unsigned>::type get_f0_offset() {
+    return 0;
+}
+
 template <typename ARCH> status riscv_target_adapter<ARCH>::set_gen_thread(rp_thread_ref& thread) {
     thread_idx = thread;
     return Ok;
@@ -175,34 +191,37 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::current_thread_query
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::read_registers(std::vector<uint8_t>& data, std::vector<uint8_t>& avail) {
     CPPLOG(TRACE) << "reading target registers";
-    // return idx<0?:;
     data.clear();
     avail.clear();
     const uint8_t* reg_base = core->get_regs_base_ptr();
     auto start_reg = arch::traits<ARCH>::X0;
-    for(size_t reg_no = start_reg; reg_no < start_reg + 33 /*arch::traits<ARCH>::NUM_REGS*/; ++reg_no) {
-        auto reg_width = arch::traits<ARCH>::reg_bit_widths[reg_no] / 8;
-        unsigned offset = traits<ARCH>::reg_byte_offsets[reg_no];
-        for(size_t j = 0; j < reg_width; ++j) {
-            data.push_back(*(reg_base + offset + j));
-            avail.push_back(0xff);
+    for(size_t i = 0; i < 33; ++i) {
+        if(i < arch::traits<ARCH>::RFS || i == arch::traits<ARCH>::PC) {
+            auto reg_no = i<32? start_reg + i: arch::traits<ARCH>::PC;
+            unsigned offset = traits<ARCH>::reg_byte_offsets[reg_no];
+            for(size_t j = 0; j < arch::traits<ARCH>::XLEN/8; ++j) {
+                data.push_back(*(reg_base + offset + j));
+                avail.push_back(0xff);
+            }
+        } else {
+            for(size_t j = 0; j < arch::traits<ARCH>::XLEN/8; ++j) {
+                data.push_back(0);
+                avail.push_back(0);
+            }
+        }
+    }
+    if(iss::arch::traits<ARCH>::FLEN > 0) {
+        auto fstart_reg = get_f0_offset<ARCH>();
+        for(size_t i = 0; i < 32; ++i) {
+            auto reg_no = fstart_reg + i;
+            auto reg_width = arch::traits<ARCH>::reg_bit_widths[reg_no] / 8;
+            unsigned offset = traits<ARCH>::reg_byte_offsets[reg_no];
+            for(size_t j = 0; j < reg_width; ++j) {
+                data.push_back(*(reg_base + offset + j));
+                avail.push_back(0xff);
+            }
         }
     }
-    // work around fill with F type registers
-    //    if (arch::traits<ARCH>::NUM_REGS < 65) {
-    //        auto reg_width = sizeof(typename arch::traits<ARCH>::reg_t);
-    //        for (size_t reg_no = 0; reg_no < 33; ++reg_no) {
-    //            for (size_t j = 0; j < reg_width; ++j) {
-    //                data.push_back(0x0);
-    //                avail.push_back(0x00);
-    //            }
-    //            // if(arch::traits<ARCH>::XLEN < 64)
-    //            //     for(unsigned j=0; j<4; ++j){
-    //            //         data.push_back(0x0);
-    //            //         avail.push_back(0x00);
-    //            //     }
-    //        }
-    //    }
     return Ok;
 }
 
@@ -210,25 +229,25 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
     auto start_reg = arch::traits<ARCH>::X0;
     auto* reg_base = core->get_regs_base_ptr();
     auto iter = data.data();
-    bool e_ext = arch::traits<ARCH>::PC < 32;
-    for(size_t reg_no = 0; reg_no < start_reg + 33 /*arch::traits<ARCH>::NUM_REGS*/; ++reg_no) {
-        if(e_ext && reg_no > 15) {
-            if(reg_no == 32) {
-                auto reg_width = arch::traits<ARCH>::reg_bit_widths[arch::traits<ARCH>::PC] / 8;
-                auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
-                std::copy(iter, iter + reg_width, reg_base);
-            } else {
-                const uint64_t zero_val = 0;
-                auto reg_width = arch::traits<ARCH>::reg_bit_widths[15] / 8;
-                auto iter = (uint8_t*)&zero_val;
-                std::copy(iter, iter + reg_width, reg_base);
-            }
-        } else {
-            auto reg_width = arch::traits<ARCH>::reg_bit_widths[reg_no] / 8;
-            auto offset = traits<ARCH>::reg_byte_offsets[reg_no];
-            std::copy(iter, iter + reg_width, reg_base);
-            iter += 4;
-            reg_base += offset;
+    auto iter_end = data.data()+data.size();
+    for(size_t i = 0; i < 33 && iter < iter_end; ++i) {
+        auto reg_width = arch::traits<ARCH>::XLEN / 8;
+        if(i < arch::traits<ARCH>::RFS) {
+            auto offset = traits<ARCH>::reg_byte_offsets[start_reg + i];
+            std::copy(iter, iter + reg_width, reg_base+offset);
+        } else if(i == 32) {
+            auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
+            std::copy(iter, iter + reg_width, reg_base+offset);
+        }
+        iter += reg_width;
+    }
+    if(iss::arch::traits<ARCH>::FLEN > 0) {
+        auto fstart_reg = get_f0_offset<ARCH>();
+        auto reg_width = arch::traits<ARCH>::FLEN / 8;
+        for(size_t i = 0; i < 32 && iter < iter_end; ++i) {
+            unsigned offset = traits<ARCH>::reg_byte_offsets[fstart_reg + i];
+            std::copy(iter, iter + reg_width, reg_base+offset);
+            iter += reg_width;
         }
     }
     return Ok;
@@ -236,7 +255,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
 
 template <typename ARCH>
 status riscv_target_adapter<ARCH>::read_single_register(unsigned int reg_no, std::vector<uint8_t>& data, std::vector<uint8_t>& avail) {
-    if(reg_no < 65) {
+    if(reg_no <csr_offset) {
         // auto reg_size = arch::traits<ARCH>::reg_bit_width(static_cast<typename
         // arch::traits<ARCH>::reg_e>(reg_no))/8;
         auto* reg_base = core->get_regs_base_ptr();
@@ -247,23 +266,24 @@ status riscv_target_adapter<ARCH>::read_single_register(unsigned int reg_no, std
         std::copy(reg_base + offset, reg_base + offset + reg_width, data.begin());
         std::fill(avail.begin(), avail.end(), 0xff);
     } else {
-        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, reg_no - 65);
+        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, reg_no - csr_offset);
         data.resize(sizeof(typename traits<ARCH>::reg_t));
         avail.resize(sizeof(typename traits<ARCH>::reg_t));
         std::fill(avail.begin(), avail.end(), 0xff);
         core->read(a, data.size(), data.data());
+        std::fill(avail.begin(), avail.end(), 0xff);
     }
     return data.size() > 0 ? Ok : Err;
 }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::write_single_register(unsigned int reg_no, const std::vector<uint8_t>& data) {
-    if(reg_no < 65) {
+    if(reg_no < csr_offset) {
         auto* reg_base = core->get_regs_base_ptr();
         auto reg_width = arch::traits<ARCH>::reg_bit_widths[static_cast<typename arch::traits<ARCH>::reg_e>(reg_no)] / 8;
         auto offset = traits<ARCH>::reg_byte_offsets[reg_no];
         std::copy(data.begin(), data.begin() + reg_width, reg_base + offset);
     } else {
-        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_WRITE, traits<ARCH>::CSR, reg_no - 65);
+        typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_WRITE, traits<ARCH>::CSR, reg_no - csr_offset);
         core->write(a, data.size(), data.data());
     }
     return Ok;
@@ -276,7 +296,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::read_mem(uint64_t ad
 }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::write_mem(uint64_t addr, const std::vector<uint8_t>& data) {
-    auto a = map_addr({iss::access_type::DEBUG_READ, iss::address_type::VIRTUAL, 0, addr});
+    auto a = map_addr({iss::access_type::DEBUG_WRITE, iss::address_type::VIRTUAL, 0, addr});
     auto f = [&]() -> status { return core->write(a, data.size(), data.data()); };
     return srv->execute_syncronized(f);
 }
@@ -329,7 +349,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::add_break(break_type
         auto eaddr = map_addr({iss::access_type::FETCH, iss::address_type::PHYSICAL, 0, addr + length});
         target_adapter_base::bp_lut.addEntry(++target_adapter_base::bp_count, saddr.val, eaddr.val - saddr.val);
         CPPLOG(TRACE) << "Adding breakpoint with handle " << target_adapter_base::bp_count << " for addr 0x" << std::hex << saddr.val
-                      << std::dec;
+                << std::dec;
         CPPLOG(TRACE) << "Now having " << target_adapter_base::bp_lut.size() << " breakpoints";
         return Ok;
     }
@@ -359,7 +379,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::remove_break(break_t
 
 template <typename ARCH>
 status riscv_target_adapter<ARCH>::resume_from_addr(bool step, int sig, uint64_t addr, rp_thread_ref thread,
-                                                    std::function<void(unsigned)> stop_callback) {
+        std::function<void(unsigned)> stop_callback) {
     auto* reg_base = core->get_regs_base_ptr();
     auto reg_width = arch::traits<ARCH>::reg_bit_widths[arch::traits<ARCH>::PC] / 8;
     auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
@@ -369,93 +389,55 @@ status riscv_target_adapter<ARCH>::resume_from_addr(bool step, int sig, uint64_t
 }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std::string& out_buf) {
-    const std::string res{"<?xml version=\"1.0\"?><!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
-                          "<target><architecture>riscv:rv32</architecture>"
-                          //"  <feature name=\"org.gnu.gdb.riscv.rv32i\">\n"
-                          //"    <reg name=\"x0\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x1\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x2\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x3\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x4\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x5\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x6\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x7\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x8\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x9\"  bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x10\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x11\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x12\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x13\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x14\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x15\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x16\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x17\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x18\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x19\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x20\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x21\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x22\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x23\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x24\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x25\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x26\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x27\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x28\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x29\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x30\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"    <reg name=\"x31\" bitsize=\"32\" group=\"general\"/>\n"
-                          //"  </feature>\n"
-                          "</target>"};
-    out_buf = res;
+    if(!csr_xml.size()) {
+        std::ostringstream oss;
+        oss << "<?xml version=\"1.0\"?><!DOCTYPE feature SYSTEM \"gdb-target.dtd\"><target version=\"1.0\">\n";
+        if(iss::arch::traits<ARCH>::XLEN == 32)
+            oss << "<architecture>riscv:rv32</architecture>\n";
+        else if(iss::arch::traits<ARCH>::XLEN == 64)
+            oss << "  <architectureriscv:rv64</architecture>\n";
+        oss << "  <feature name=\"org.gnu.gdb.riscv.cpu\">\n";
+        auto reg_base_num = iss::arch::traits<ARCH>::X0;
+        for(auto i = 0U; i<iss::arch::traits<ARCH>::RFS; ++i) {
+            oss << "    <reg name=\"x" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i] << "\" type=\"int\" regnum=\"" << i << "\"/>\n";
+        }
+        oss << "    <reg name=\"pc\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[iss::arch::traits<ARCH>::PC] << "\" type=\"code_ptr\" regnum=\"" << 32U << "\"/>\n";
+        oss << "  </feature>\n";
+        if(iss::arch::traits<ARCH>::FLEN > 0) {
+            oss << "  <feature name=\"org.gnu.gdb.riscv.fpu\">\n";
+            auto reg_base_num =  get_f0_offset<ARCH>();
+            auto type = iss::arch::traits<ARCH>::FLEN==32?"ieee_single":"riscv_double";
+            for(auto i = 0U; i<32; ++i) {
+                oss << "    <reg name=\"f" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i] << "\" type=\""<<type<<"\" regnum=\"" << i+33 << "\"/>\n";
+            }
+            oss << "    <reg name=\"fcsr\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\" regnum=\"103\" type int/>\n";
+            oss << "    <reg name=\"fflags\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\" regnum=\"101\" type int/>\n";
+            oss << "    <reg name=\"frm\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\" regnum=\"102\" type int/>\n";
+            oss << "  </feature>\n";
+        }
+        oss << "  <feature name=\"org.gnu.gdb.riscv.csr\">\n";
+        std::vector<uint8_t> data;
+        std::vector<uint8_t> avail;
+        data.resize(sizeof(typename traits<ARCH>::reg_t));
+        avail.resize(sizeof(typename traits<ARCH>::reg_t));
+        for(auto i = 0U; i<4096; ++i) {
+            typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, i);
+            std::fill(avail.begin(), avail.end(), 0xff);
+            auto res = core->read(a, data.size(), data.data());
+            if(res == iss::Ok) {
+                oss << "    <reg name=\"" << get_csr_name(i) << "\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\"  type=\"int\" regnum=\"" << (i + csr_offset) << "\"/>\n";
+            }
+        }
+        oss << "  </feature>\n";
+        oss << "</target>\n";
+        csr_xml = oss.str();
+        std::ofstream ofs("target.xml");
+        ofs<<csr_xml;
+    }
+    out_buf = csr_xml;
     return Ok;
 }
-
-/*
- *
-<?xml version="1.0"?>
-<!DOCTYPE target SYSTEM "gdb-target.dtd">
-<target>
-  <architecture>riscv:rv32</architecture>
-
-  <feature name="org.gnu.gdb.riscv.rv32i">
-    <reg name="x0"  bitsize="32" group="general"/>
-    <reg name="x1"  bitsize="32" group="general"/>
-    <reg name="x2"  bitsize="32" group="general"/>
-    <reg name="x3"  bitsize="32" group="general"/>
-    <reg name="x4"  bitsize="32" group="general"/>
-    <reg name="x5"  bitsize="32" group="general"/>
-    <reg name="x6"  bitsize="32" group="general"/>
-    <reg name="x7"  bitsize="32" group="general"/>
-    <reg name="x8"  bitsize="32" group="general"/>
-    <reg name="x9"  bitsize="32" group="general"/>
-    <reg name="x10" bitsize="32" group="general"/>
-    <reg name="x11" bitsize="32" group="general"/>
-    <reg name="x12" bitsize="32" group="general"/>
-    <reg name="x13" bitsize="32" group="general"/>
-    <reg name="x14" bitsize="32" group="general"/>
-    <reg name="x15" bitsize="32" group="general"/>
-    <reg name="x16" bitsize="32" group="general"/>
-    <reg name="x17" bitsize="32" group="general"/>
-    <reg name="x18" bitsize="32" group="general"/>
-    <reg name="x19" bitsize="32" group="general"/>
-    <reg name="x20" bitsize="32" group="general"/>
-    <reg name="x21" bitsize="32" group="general"/>
-    <reg name="x22" bitsize="32" group="general"/>
-    <reg name="x23" bitsize="32" group="general"/>
-    <reg name="x24" bitsize="32" group="general"/>
-    <reg name="x25" bitsize="32" group="general"/>
-    <reg name="x26" bitsize="32" group="general"/>
-    <reg name="x27" bitsize="32" group="general"/>
-    <reg name="x28" bitsize="32" group="general"/>
-    <reg name="x29" bitsize="32" group="general"/>
-    <reg name="x30" bitsize="32" group="general"/>
-    <reg name="x31" bitsize="32" group="general"/>
-  </feature>
-
-</target>
-
- */
 } // namespace debugger
 } // namespace iss
 
-#endif /* _ISS_DEBUGGER_RISCV_TARGET_ADAPTER_H_ */
+#endif /* _ISS_ARCH_DEBUGGER_RISCV_TARGET_ADAPTER_H_ */

From 0996d15bd406d3a73f4860d57b9d468444043843 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 12:48:48 +0200
Subject: [PATCH 082/100] removes debug code

---
 src/iss/debugger/riscv_target_adapter.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/iss/debugger/riscv_target_adapter.h b/src/iss/debugger/riscv_target_adapter.h
index 5ee48d2..83e9fcf 100644
--- a/src/iss/debugger/riscv_target_adapter.h
+++ b/src/iss/debugger/riscv_target_adapter.h
@@ -430,9 +430,6 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
         }
         oss << "  </feature>\n";
         oss << "</target>\n";
-        csr_xml = oss.str();
-        std::ofstream ofs("target.xml");
-        ofs<<csr_xml;
     }
     out_buf = csr_xml;
     return Ok;

From bb4e2766d11fdfbf2908d99b3b11114fd37e93bc Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 13:33:14 +0200
Subject: [PATCH 083/100] applies clang-format

---
 gen_input/templates/llvm/CORENAME.cpp.gtl |    4 +-
 src/iss/arch/riscv_hart_m_p.h             |    4 +-
 src/iss/arch/riscv_hart_msu_vp.h          |   18 +-
 src/iss/arch/riscv_hart_mu_p.h            |   22 +-
 src/iss/debugger/csr_names.cpp            | 8196 ++++++++++-----------
 src/iss/debugger/riscv_target_adapter.h   |   54 +-
 src/sysc/core_complex.cpp                 |   55 +-
 src/sysc/core_complex.h                   |   23 +-
 src/sysc/sc_core_adapter.h                |    6 +-
 9 files changed, 4185 insertions(+), 4197 deletions(-)

diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index f362493..bcdf909 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -204,7 +204,7 @@ private:
             };
             this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
-		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
+        this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
         this->builder.CreateStore(
@@ -381,4 +381,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
\ No newline at end of file
+// clang-format on
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 8b27dec..70fd958 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -602,7 +602,7 @@ std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::str
             if(reader.get_machine() != EM_RISCV)
                 throw std::runtime_error("wrong elf machine in file");
             auto entry = reader.get_entry();
-            for(const auto pseg : reader.segments) {
+            for(const auto& pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
@@ -689,7 +689,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read(const address_type type, co
                 }
                 return res;
             } catch(trap_access& ta) {
-                if( (access & access_type::DEBUG) == 0) {
+                if((access & access_type::DEBUG) == 0) {
                     this->reg.trap_state = (1UL << 31) | ta.id;
                     fault_data = ta.addr;
                 }
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 66cdc1b..233560f 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -671,8 +671,10 @@ iss::status riscv_hart_msu_vp<BASE>::read(const address_type type, const access_
                 }
                 return res;
             } catch(trap_access& ta) {
-                this->reg.trap_state = (1 << 31) | ta.id;
-                fault_data = ta.addr;
+                if((access & access_type::DEBUG) == 0) {
+                    this->reg.trap_state = (1UL << 31) | ta.id;
+                    fault_data = ta.addr;
+                }
                 return iss::Err;
             }
         } break;
@@ -710,8 +712,10 @@ iss::status riscv_hart_msu_vp<BASE>::read(const address_type type, const access_
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
@@ -841,8 +845,10 @@ iss::status riscv_hart_msu_vp<BASE>::write(const address_type type, const access
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index bfcb31d..617814d 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -674,7 +674,7 @@ std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::st
             if(reader.get_machine() != EM_RISCV)
                 throw std::runtime_error("wrong elf machine in file");
             auto entry = reader.get_entry();
-            for(const auto pseg : reader.segments) {
+            for(const auto& pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
@@ -685,7 +685,7 @@ std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::st
                         CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
                 }
             }
-            for(const auto sec : reader.sections) {
+            for(const auto& sec : reader.sections) {
                 if(sec->get_name() == ".symtab") {
                     if(SHT_SYMTAB == sec->get_type() || SHT_DYNSYM == sec->get_type()) {
                         ELFIO::symbol_section_accessor symbols(reader, sec);
@@ -877,8 +877,10 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, c
                 }
                 return res;
             } catch(trap_access& ta) {
-                this->reg.trap_state = (1UL << 31) | ta.id;
-                fault_data = ta.addr;
+                if((access & access_type::DEBUG) == 0) {
+                    this->reg.trap_state = (1UL << 31) | ta.id;
+                    fault_data = ta.addr;
+                }
                 return iss::Err;
             }
         } break;
@@ -905,8 +907,10 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read(const address_type type, c
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
@@ -1045,8 +1049,10 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write(const address_type type,
         }
         return iss::Ok;
     } catch(trap_access& ta) {
-        this->reg.trap_state = (1UL << 31) | ta.id;
-        fault_data = ta.addr;
+        if((access & access_type::DEBUG) == 0) {
+            this->reg.trap_state = (1UL << 31) | ta.id;
+            fault_data = ta.addr;
+        }
         return iss::Err;
     }
 }
diff --git a/src/iss/debugger/csr_names.cpp b/src/iss/debugger/csr_names.cpp
index f1c35e2..f238130 100644
--- a/src/iss/debugger/csr_names.cpp
+++ b/src/iss/debugger/csr_names.cpp
@@ -5,4104 +5,4104 @@
 namespace iss {
 namespace debugger {
 const std::array<char const* const, 4096> csr_names = {
-        "unknown", // 0
-         "fflags", // 1
-         "frm", // 2
-         "fcsr", // 3
-        "unknown", // 4
-        "unknown", // 5
-        "unknown", // 6
-         "utvt", // 7
-         "vstart", // 8
-         "vxsat", // 9
-         "vxrm", // 10
-        "unknown", // 11
-        "unknown", // 12
-        "unknown", // 13
-        "unknown", // 14
-         "vcsr", // 15
-        "unknown", // 16
-         "ssp", // 17
-        "unknown", // 18
-        "unknown", // 19
-        "unknown", // 20
-         "seed", // 21
-        "unknown", // 22
-         "jvt", // 23
-        "unknown", // 24
-        "unknown", // 25
-        "unknown", // 26
-        "unknown", // 27
-        "unknown", // 28
-        "unknown", // 29
-        "unknown", // 30
-        "unknown", // 31
-        "unknown", // 32
-        "unknown", // 33
-        "unknown", // 34
-        "unknown", // 35
-        "unknown", // 36
-        "unknown", // 37
-        "unknown", // 38
-        "unknown", // 39
-        "unknown", // 40
-        "unknown", // 41
-        "unknown", // 42
-        "unknown", // 43
-        "unknown", // 44
-        "unknown", // 45
-        "unknown", // 46
-        "unknown", // 47
-        "unknown", // 48
-        "unknown", // 49
-        "unknown", // 50
-        "unknown", // 51
-        "unknown", // 52
-        "unknown", // 53
-        "unknown", // 54
-        "unknown", // 55
-        "unknown", // 56
-        "unknown", // 57
-        "unknown", // 58
-        "unknown", // 59
-        "unknown", // 60
-        "unknown", // 61
-        "unknown", // 62
-        "unknown", // 63
-        "unknown", // 64
-        "unknown", // 65
-        "unknown", // 66
-        "unknown", // 67
-        "unknown", // 68
-         "unxti", // 69
-         "uintstatus", // 70
-        "unknown", // 71
-         "uscratchcsw", // 72
-         "uscratchcswl", // 73
-        "unknown", // 74
-        "unknown", // 75
-        "unknown", // 76
-        "unknown", // 77
-        "unknown", // 78
-        "unknown", // 79
-        "unknown", // 80
-        "unknown", // 81
-        "unknown", // 82
-        "unknown", // 83
-        "unknown", // 84
-        "unknown", // 85
-        "unknown", // 86
-        "unknown", // 87
-        "unknown", // 88
-        "unknown", // 89
-        "unknown", // 90
-        "unknown", // 91
-        "unknown", // 92
-        "unknown", // 93
-        "unknown", // 94
-        "unknown", // 95
-        "unknown", // 96
-        "unknown", // 97
-        "unknown", // 98
-        "unknown", // 99
-        "unknown", // 100
-        "unknown", // 101
-        "unknown", // 102
-        "unknown", // 103
-        "unknown", // 104
-        "unknown", // 105
-        "unknown", // 106
-        "unknown", // 107
-        "unknown", // 108
-        "unknown", // 109
-        "unknown", // 110
-        "unknown", // 111
-        "unknown", // 112
-        "unknown", // 113
-        "unknown", // 114
-        "unknown", // 115
-        "unknown", // 116
-        "unknown", // 117
-        "unknown", // 118
-        "unknown", // 119
-        "unknown", // 120
-        "unknown", // 121
-        "unknown", // 122
-        "unknown", // 123
-        "unknown", // 124
-        "unknown", // 125
-        "unknown", // 126
-        "unknown", // 127
-        "unknown", // 128
-        "unknown", // 129
-        "unknown", // 130
-        "unknown", // 131
-        "unknown", // 132
-        "unknown", // 133
-        "unknown", // 134
-        "unknown", // 135
-        "unknown", // 136
-        "unknown", // 137
-        "unknown", // 138
-        "unknown", // 139
-        "unknown", // 140
-        "unknown", // 141
-        "unknown", // 142
-        "unknown", // 143
-        "unknown", // 144
-        "unknown", // 145
-        "unknown", // 146
-        "unknown", // 147
-        "unknown", // 148
-        "unknown", // 149
-        "unknown", // 150
-        "unknown", // 151
-        "unknown", // 152
-        "unknown", // 153
-        "unknown", // 154
-        "unknown", // 155
-        "unknown", // 156
-        "unknown", // 157
-        "unknown", // 158
-        "unknown", // 159
-        "unknown", // 160
-        "unknown", // 161
-        "unknown", // 162
-        "unknown", // 163
-        "unknown", // 164
-        "unknown", // 165
-        "unknown", // 166
-        "unknown", // 167
-        "unknown", // 168
-        "unknown", // 169
-        "unknown", // 170
-        "unknown", // 171
-        "unknown", // 172
-        "unknown", // 173
-        "unknown", // 174
-        "unknown", // 175
-        "unknown", // 176
-        "unknown", // 177
-        "unknown", // 178
-        "unknown", // 179
-        "unknown", // 180
-        "unknown", // 181
-        "unknown", // 182
-        "unknown", // 183
-        "unknown", // 184
-        "unknown", // 185
-        "unknown", // 186
-        "unknown", // 187
-        "unknown", // 188
-        "unknown", // 189
-        "unknown", // 190
-        "unknown", // 191
-        "unknown", // 192
-        "unknown", // 193
-        "unknown", // 194
-        "unknown", // 195
-        "unknown", // 196
-        "unknown", // 197
-        "unknown", // 198
-        "unknown", // 199
-        "unknown", // 200
-        "unknown", // 201
-        "unknown", // 202
-        "unknown", // 203
-        "unknown", // 204
-        "unknown", // 205
-        "unknown", // 206
-        "unknown", // 207
-        "unknown", // 208
-        "unknown", // 209
-        "unknown", // 210
-        "unknown", // 211
-        "unknown", // 212
-        "unknown", // 213
-        "unknown", // 214
-        "unknown", // 215
-        "unknown", // 216
-        "unknown", // 217
-        "unknown", // 218
-        "unknown", // 219
-        "unknown", // 220
-        "unknown", // 221
-        "unknown", // 222
-        "unknown", // 223
-        "unknown", // 224
-        "unknown", // 225
-        "unknown", // 226
-        "unknown", // 227
-        "unknown", // 228
-        "unknown", // 229
-        "unknown", // 230
-        "unknown", // 231
-        "unknown", // 232
-        "unknown", // 233
-        "unknown", // 234
-        "unknown", // 235
-        "unknown", // 236
-        "unknown", // 237
-        "unknown", // 238
-        "unknown", // 239
-        "unknown", // 240
-        "unknown", // 241
-        "unknown", // 242
-        "unknown", // 243
-        "unknown", // 244
-        "unknown", // 245
-        "unknown", // 246
-        "unknown", // 247
-        "unknown", // 248
-        "unknown", // 249
-        "unknown", // 250
-        "unknown", // 251
-        "unknown", // 252
-        "unknown", // 253
-        "unknown", // 254
-        "unknown", // 255
-         "sstatus", // 256
-        "unknown", // 257
-         "sedeleg", // 258
-         "sideleg", // 259
-         "sie", // 260
-         "stvec", // 261
-         "scounteren", // 262
-         "stvt", // 263
-        "unknown", // 264
-        "unknown", // 265
-         "senvcfg", // 266
-        "unknown", // 267
-         "sstateen0", // 268
-         "sstateen1", // 269
-         "sstateen2", // 270
-         "sstateen3", // 271
-        "unknown", // 272
-        "unknown", // 273
-        "unknown", // 274
-        "unknown", // 275
-         "sieh", // 276
-        "unknown", // 277
-        "unknown", // 278
-        "unknown", // 279
-        "unknown", // 280
-        "unknown", // 281
-        "unknown", // 282
-        "unknown", // 283
-        "unknown", // 284
-        "unknown", // 285
-        "unknown", // 286
-        "unknown", // 287
-         "scountinhibit", // 288
-        "unknown", // 289
-        "unknown", // 290
-        "unknown", // 291
-        "unknown", // 292
-        "unknown", // 293
-        "unknown", // 294
-        "unknown", // 295
-        "unknown", // 296
-        "unknown", // 297
-        "unknown", // 298
-        "unknown", // 299
-        "unknown", // 300
-        "unknown", // 301
-        "unknown", // 302
-        "unknown", // 303
-        "unknown", // 304
-        "unknown", // 305
-        "unknown", // 306
-        "unknown", // 307
-        "unknown", // 308
-        "unknown", // 309
-        "unknown", // 310
-        "unknown", // 311
-        "unknown", // 312
-        "unknown", // 313
-        "unknown", // 314
-        "unknown", // 315
-        "unknown", // 316
-        "unknown", // 317
-        "unknown", // 318
-        "unknown", // 319
-         "sscratch", // 320
-         "sepc", // 321
-         "scause", // 322
-         "stval", // 323
-         "sip", // 324
-         "snxti", // 325
-         "sintstatus", // 326
-        "unknown", // 327
-         "sscratchcsw", // 328
-         "sscratchcswl", // 329
-        "unknown", // 330
-        "unknown", // 331
-        "unknown", // 332
-         "stimecmp", // 333
-         "sctrctl", // 334
-         "sctrstatus", // 335
-         "siselect", // 336
-         "sireg", // 337
-         "sireg2", // 338
-         "sireg3", // 339
-         "siph", // 340
-         "sireg4", // 341
-         "sireg5", // 342
-         "sireg6", // 343
-        "unknown", // 344
-        "unknown", // 345
-        "unknown", // 346
-        "unknown", // 347
-         "stopei", // 348
-         "stimecmph", // 349
-        "unknown", // 350
-         "sctrdepth", // 351
-        "unknown", // 352
-        "unknown", // 353
-        "unknown", // 354
-        "unknown", // 355
-        "unknown", // 356
-        "unknown", // 357
-        "unknown", // 358
-        "unknown", // 359
-        "unknown", // 360
-        "unknown", // 361
-        "unknown", // 362
-        "unknown", // 363
-        "unknown", // 364
-        "unknown", // 365
-        "unknown", // 366
-        "unknown", // 367
-        "unknown", // 368
-        "unknown", // 369
-        "unknown", // 370
-        "unknown", // 371
-        "unknown", // 372
-        "unknown", // 373
-        "unknown", // 374
-        "unknown", // 375
-        "unknown", // 376
-        "unknown", // 377
-        "unknown", // 378
-        "unknown", // 379
-        "unknown", // 380
-        "unknown", // 381
-        "unknown", // 382
-        "unknown", // 383
-         "satp", // 384
-         "srmcfg", // 385
-        "unknown", // 386
-        "unknown", // 387
-        "unknown", // 388
-        "unknown", // 389
-        "unknown", // 390
-        "unknown", // 391
-        "unknown", // 392
-        "unknown", // 393
-        "unknown", // 394
-        "unknown", // 395
-        "unknown", // 396
-        "unknown", // 397
-        "unknown", // 398
-        "unknown", // 399
-        "unknown", // 400
-        "unknown", // 401
-        "unknown", // 402
-        "unknown", // 403
-        "unknown", // 404
-        "unknown", // 405
-        "unknown", // 406
-        "unknown", // 407
-        "unknown", // 408
-        "unknown", // 409
-        "unknown", // 410
-        "unknown", // 411
-        "unknown", // 412
-        "unknown", // 413
-        "unknown", // 414
-        "unknown", // 415
-        "unknown", // 416
-        "unknown", // 417
-        "unknown", // 418
-        "unknown", // 419
-        "unknown", // 420
-        "unknown", // 421
-        "unknown", // 422
-        "unknown", // 423
-        "unknown", // 424
-        "unknown", // 425
-        "unknown", // 426
-        "unknown", // 427
-        "unknown", // 428
-        "unknown", // 429
-        "unknown", // 430
-        "unknown", // 431
-        "unknown", // 432
-        "unknown", // 433
-        "unknown", // 434
-        "unknown", // 435
-        "unknown", // 436
-        "unknown", // 437
-        "unknown", // 438
-        "unknown", // 439
-        "unknown", // 440
-        "unknown", // 441
-        "unknown", // 442
-        "unknown", // 443
-        "unknown", // 444
-        "unknown", // 445
-        "unknown", // 446
-        "unknown", // 447
-        "unknown", // 448
-        "unknown", // 449
-        "unknown", // 450
-        "unknown", // 451
-        "unknown", // 452
-        "unknown", // 453
-        "unknown", // 454
-        "unknown", // 455
-        "unknown", // 456
-        "unknown", // 457
-        "unknown", // 458
-        "unknown", // 459
-        "unknown", // 460
-        "unknown", // 461
-        "unknown", // 462
-        "unknown", // 463
-        "unknown", // 464
-        "unknown", // 465
-        "unknown", // 466
-        "unknown", // 467
-        "unknown", // 468
-        "unknown", // 469
-        "unknown", // 470
-        "unknown", // 471
-        "unknown", // 472
-        "unknown", // 473
-        "unknown", // 474
-        "unknown", // 475
-        "unknown", // 476
-        "unknown", // 477
-        "unknown", // 478
-        "unknown", // 479
-        "unknown", // 480
-        "unknown", // 481
-        "unknown", // 482
-        "unknown", // 483
-        "unknown", // 484
-        "unknown", // 485
-        "unknown", // 486
-        "unknown", // 487
-        "unknown", // 488
-        "unknown", // 489
-        "unknown", // 490
-        "unknown", // 491
-        "unknown", // 492
-        "unknown", // 493
-        "unknown", // 494
-        "unknown", // 495
-        "unknown", // 496
-        "unknown", // 497
-        "unknown", // 498
-        "unknown", // 499
-        "unknown", // 500
-        "unknown", // 501
-        "unknown", // 502
-        "unknown", // 503
-        "unknown", // 504
-        "unknown", // 505
-        "unknown", // 506
-        "unknown", // 507
-        "unknown", // 508
-        "unknown", // 509
-        "unknown", // 510
-        "unknown", // 511
-         "vsstatus", // 512
-        "unknown", // 513
-        "unknown", // 514
-        "unknown", // 515
-         "vsie", // 516
-         "vstvec", // 517
-        "unknown", // 518
-        "unknown", // 519
-        "unknown", // 520
-        "unknown", // 521
-        "unknown", // 522
-        "unknown", // 523
-        "unknown", // 524
-        "unknown", // 525
-        "unknown", // 526
-        "unknown", // 527
-        "unknown", // 528
-        "unknown", // 529
-        "unknown", // 530
-        "unknown", // 531
-         "vsieh", // 532
-        "unknown", // 533
-        "unknown", // 534
-        "unknown", // 535
-        "unknown", // 536
-        "unknown", // 537
-        "unknown", // 538
-        "unknown", // 539
-        "unknown", // 540
-        "unknown", // 541
-        "unknown", // 542
-        "unknown", // 543
-        "unknown", // 544
-        "unknown", // 545
-        "unknown", // 546
-        "unknown", // 547
-        "unknown", // 548
-        "unknown", // 549
-        "unknown", // 550
-        "unknown", // 551
-        "unknown", // 552
-        "unknown", // 553
-        "unknown", // 554
-        "unknown", // 555
-        "unknown", // 556
-        "unknown", // 557
-        "unknown", // 558
-        "unknown", // 559
-        "unknown", // 560
-        "unknown", // 561
-        "unknown", // 562
-        "unknown", // 563
-        "unknown", // 564
-        "unknown", // 565
-        "unknown", // 566
-        "unknown", // 567
-        "unknown", // 568
-        "unknown", // 569
-        "unknown", // 570
-        "unknown", // 571
-        "unknown", // 572
-        "unknown", // 573
-        "unknown", // 574
-        "unknown", // 575
-         "vsscratch", // 576
-         "vsepc", // 577
-         "vscause", // 578
-         "vstval", // 579
-         "vsip", // 580
-        "unknown", // 581
-        "unknown", // 582
-        "unknown", // 583
-        "unknown", // 584
-        "unknown", // 585
-        "unknown", // 586
-        "unknown", // 587
-        "unknown", // 588
-         "vstimecmp", // 589
-         "vsctrctl", // 590
-        "unknown", // 591
-         "vsiselect", // 592
-         "vsireg", // 593
-         "vsireg2", // 594
-         "vsireg3", // 595
-         "vsiph", // 596
-         "vsireg4", // 597
-         "vsireg5", // 598
-         "vsireg6", // 599
-        "unknown", // 600
-        "unknown", // 601
-        "unknown", // 602
-        "unknown", // 603
-         "vstopei", // 604
-         "vstimecmph", // 605
-        "unknown", // 606
-        "unknown", // 607
-        "unknown", // 608
-        "unknown", // 609
-        "unknown", // 610
-        "unknown", // 611
-        "unknown", // 612
-        "unknown", // 613
-        "unknown", // 614
-        "unknown", // 615
-        "unknown", // 616
-        "unknown", // 617
-        "unknown", // 618
-        "unknown", // 619
-        "unknown", // 620
-        "unknown", // 621
-        "unknown", // 622
-        "unknown", // 623
-        "unknown", // 624
-        "unknown", // 625
-        "unknown", // 626
-        "unknown", // 627
-        "unknown", // 628
-        "unknown", // 629
-        "unknown", // 630
-        "unknown", // 631
-        "unknown", // 632
-        "unknown", // 633
-        "unknown", // 634
-        "unknown", // 635
-        "unknown", // 636
-        "unknown", // 637
-        "unknown", // 638
-        "unknown", // 639
-         "vsatp", // 640
-        "unknown", // 641
-        "unknown", // 642
-        "unknown", // 643
-        "unknown", // 644
-        "unknown", // 645
-        "unknown", // 646
-        "unknown", // 647
-        "unknown", // 648
-        "unknown", // 649
-        "unknown", // 650
-        "unknown", // 651
-        "unknown", // 652
-        "unknown", // 653
-        "unknown", // 654
-        "unknown", // 655
-        "unknown", // 656
-        "unknown", // 657
-        "unknown", // 658
-        "unknown", // 659
-        "unknown", // 660
-        "unknown", // 661
-        "unknown", // 662
-        "unknown", // 663
-        "unknown", // 664
-        "unknown", // 665
-        "unknown", // 666
-        "unknown", // 667
-        "unknown", // 668
-        "unknown", // 669
-        "unknown", // 670
-        "unknown", // 671
-        "unknown", // 672
-        "unknown", // 673
-        "unknown", // 674
-        "unknown", // 675
-        "unknown", // 676
-        "unknown", // 677
-        "unknown", // 678
-        "unknown", // 679
-        "unknown", // 680
-        "unknown", // 681
-        "unknown", // 682
-        "unknown", // 683
-        "unknown", // 684
-        "unknown", // 685
-        "unknown", // 686
-        "unknown", // 687
-        "unknown", // 688
-        "unknown", // 689
-        "unknown", // 690
-        "unknown", // 691
-        "unknown", // 692
-        "unknown", // 693
-        "unknown", // 694
-        "unknown", // 695
-        "unknown", // 696
-        "unknown", // 697
-        "unknown", // 698
-        "unknown", // 699
-        "unknown", // 700
-        "unknown", // 701
-        "unknown", // 702
-        "unknown", // 703
-        "unknown", // 704
-        "unknown", // 705
-        "unknown", // 706
-        "unknown", // 707
-        "unknown", // 708
-        "unknown", // 709
-        "unknown", // 710
-        "unknown", // 711
-        "unknown", // 712
-        "unknown", // 713
-        "unknown", // 714
-        "unknown", // 715
-        "unknown", // 716
-        "unknown", // 717
-        "unknown", // 718
-        "unknown", // 719
-        "unknown", // 720
-        "unknown", // 721
-        "unknown", // 722
-        "unknown", // 723
-        "unknown", // 724
-        "unknown", // 725
-        "unknown", // 726
-        "unknown", // 727
-        "unknown", // 728
-        "unknown", // 729
-        "unknown", // 730
-        "unknown", // 731
-        "unknown", // 732
-        "unknown", // 733
-        "unknown", // 734
-        "unknown", // 735
-        "unknown", // 736
-        "unknown", // 737
-        "unknown", // 738
-        "unknown", // 739
-        "unknown", // 740
-        "unknown", // 741
-        "unknown", // 742
-        "unknown", // 743
-        "unknown", // 744
-        "unknown", // 745
-        "unknown", // 746
-        "unknown", // 747
-        "unknown", // 748
-        "unknown", // 749
-        "unknown", // 750
-        "unknown", // 751
-        "unknown", // 752
-        "unknown", // 753
-        "unknown", // 754
-        "unknown", // 755
-        "unknown", // 756
-        "unknown", // 757
-        "unknown", // 758
-        "unknown", // 759
-        "unknown", // 760
-        "unknown", // 761
-        "unknown", // 762
-        "unknown", // 763
-        "unknown", // 764
-        "unknown", // 765
-        "unknown", // 766
-        "unknown", // 767
-         "mstatus", // 768
-         "misa", // 769
-         "medeleg", // 770
-         "mideleg", // 771
-         "mie", // 772
-         "mtvec", // 773
-         "mcounteren", // 774
-         "mtvt", // 775
-         "mvien", // 776
-         "mvip", // 777
-         "menvcfg", // 778
-        "unknown", // 779
-         "mstateen0", // 780
-         "mstateen1", // 781
-         "mstateen2", // 782
-         "mstateen3", // 783
-         "mstatush", // 784
-        "unknown", // 785
-        "unknown", // 786
-         "midelegh", // 787
-         "mieh", // 788
-        "unknown", // 789
-        "unknown", // 790
-        "unknown", // 791
-         "mvienh", // 792
-         "mviph", // 793
-         "menvcfgh", // 794
-        "unknown", // 795
-         "mstateen0h", // 796
-         "mstateen1h", // 797
-         "mstateen2h", // 798
-         "mstateen3h", // 799
-         "mcountinhibit", // 800
-         "mcyclecfg", // 801
-         "minstretcfg", // 802
-         "mhpmevent3", // 803
-         "mhpmevent4", // 804
-         "mhpmevent5", // 805
-         "mhpmevent6", // 806
-         "mhpmevent7", // 807
-         "mhpmevent8", // 808
-         "mhpmevent9", // 809
-         "mhpmevent10", // 810
-         "mhpmevent11", // 811
-         "mhpmevent12", // 812
-         "mhpmevent13", // 813
-         "mhpmevent14", // 814
-         "mhpmevent15", // 815
-         "mhpmevent16", // 816
-         "mhpmevent17", // 817
-         "mhpmevent18", // 818
-         "mhpmevent19", // 819
-         "mhpmevent20", // 820
-         "mhpmevent21", // 821
-         "mhpmevent22", // 822
-         "mhpmevent23", // 823
-         "mhpmevent24", // 824
-         "mhpmevent25", // 825
-         "mhpmevent26", // 826
-         "mhpmevent27", // 827
-         "mhpmevent28", // 828
-         "mhpmevent29", // 829
-         "mhpmevent30", // 830
-         "mhpmevent31", // 831
-         "mscratch", // 832
-         "mepc", // 833
-         "mcause", // 834
-         "mtval", // 835
-         "mip", // 836
-         "mnxti", // 837
-         "mintstatus", // 838
-        "unknown", // 839
-         "mscratchcsw", // 840
-         "mscratchcswl", // 841
-         "mtinst", // 842
-         "mtval2", // 843
-        "unknown", // 844
-        "unknown", // 845
-         "mctrctl", // 846
-        "unknown", // 847
-         "miselect", // 848
-         "mireg", // 849
-         "mireg2", // 850
-         "mireg3", // 851
-         "miph", // 852
-         "mireg4", // 853
-         "mireg5", // 854
-         "mireg6", // 855
-        "unknown", // 856
-        "unknown", // 857
-        "unknown", // 858
-        "unknown", // 859
-         "mtopei", // 860
-        "unknown", // 861
-        "unknown", // 862
-        "unknown", // 863
-        "unknown", // 864
-        "unknown", // 865
-        "unknown", // 866
-        "unknown", // 867
-        "unknown", // 868
-        "unknown", // 869
-        "unknown", // 870
-        "unknown", // 871
-        "unknown", // 872
-        "unknown", // 873
-        "unknown", // 874
-        "unknown", // 875
-        "unknown", // 876
-        "unknown", // 877
-        "unknown", // 878
-        "unknown", // 879
-        "unknown", // 880
-        "unknown", // 881
-        "unknown", // 882
-        "unknown", // 883
-        "unknown", // 884
-        "unknown", // 885
-        "unknown", // 886
-        "unknown", // 887
-        "unknown", // 888
-        "unknown", // 889
-        "unknown", // 890
-        "unknown", // 891
-        "unknown", // 892
-        "unknown", // 893
-        "unknown", // 894
-        "unknown", // 895
-        "unknown", // 896
-        "unknown", // 897
-        "unknown", // 898
-        "unknown", // 899
-        "unknown", // 900
-        "unknown", // 901
-        "unknown", // 902
-        "unknown", // 903
-        "unknown", // 904
-        "unknown", // 905
-        "unknown", // 906
-        "unknown", // 907
-        "unknown", // 908
-        "unknown", // 909
-        "unknown", // 910
-        "unknown", // 911
-        "unknown", // 912
-        "unknown", // 913
-        "unknown", // 914
-        "unknown", // 915
-        "unknown", // 916
-        "unknown", // 917
-        "unknown", // 918
-        "unknown", // 919
-        "unknown", // 920
-        "unknown", // 921
-        "unknown", // 922
-        "unknown", // 923
-        "unknown", // 924
-        "unknown", // 925
-        "unknown", // 926
-        "unknown", // 927
-         "pmpcfg0", // 928
-         "pmpcfg1", // 929
-         "pmpcfg2", // 930
-         "pmpcfg3", // 931
-         "pmpcfg4", // 932
-         "pmpcfg5", // 933
-         "pmpcfg6", // 934
-         "pmpcfg7", // 935
-         "pmpcfg8", // 936
-         "pmpcfg9", // 937
-         "pmpcfg10", // 938
-         "pmpcfg11", // 939
-         "pmpcfg12", // 940
-         "pmpcfg13", // 941
-         "pmpcfg14", // 942
-         "pmpcfg15", // 943
-         "pmpaddr0", // 944
-         "pmpaddr1", // 945
-         "pmpaddr2", // 946
-         "pmpaddr3", // 947
-         "pmpaddr4", // 948
-         "pmpaddr5", // 949
-         "pmpaddr6", // 950
-         "pmpaddr7", // 951
-         "pmpaddr8", // 952
-         "pmpaddr9", // 953
-         "pmpaddr10", // 954
-         "pmpaddr11", // 955
-         "pmpaddr12", // 956
-         "pmpaddr13", // 957
-         "pmpaddr14", // 958
-         "pmpaddr15", // 959
-         "pmpaddr16", // 960
-         "pmpaddr17", // 961
-         "pmpaddr18", // 962
-         "pmpaddr19", // 963
-         "pmpaddr20", // 964
-         "pmpaddr21", // 965
-         "pmpaddr22", // 966
-         "pmpaddr23", // 967
-         "pmpaddr24", // 968
-         "pmpaddr25", // 969
-         "pmpaddr26", // 970
-         "pmpaddr27", // 971
-         "pmpaddr28", // 972
-         "pmpaddr29", // 973
-         "pmpaddr30", // 974
-         "pmpaddr31", // 975
-         "pmpaddr32", // 976
-         "pmpaddr33", // 977
-         "pmpaddr34", // 978
-         "pmpaddr35", // 979
-         "pmpaddr36", // 980
-         "pmpaddr37", // 981
-         "pmpaddr38", // 982
-         "pmpaddr39", // 983
-         "pmpaddr40", // 984
-         "pmpaddr41", // 985
-         "pmpaddr42", // 986
-         "pmpaddr43", // 987
-         "pmpaddr44", // 988
-         "pmpaddr45", // 989
-         "pmpaddr46", // 990
-         "pmpaddr47", // 991
-         "pmpaddr48", // 992
-         "pmpaddr49", // 993
-         "pmpaddr50", // 994
-         "pmpaddr51", // 995
-         "pmpaddr52", // 996
-         "pmpaddr53", // 997
-         "pmpaddr54", // 998
-         "pmpaddr55", // 999
-         "pmpaddr56", // 1000
-         "pmpaddr57", // 1001
-         "pmpaddr58", // 1002
-         "pmpaddr59", // 1003
-         "pmpaddr60", // 1004
-         "pmpaddr61", // 1005
-         "pmpaddr62", // 1006
-         "pmpaddr63", // 1007
-        "unknown", // 1008
-        "unknown", // 1009
-        "unknown", // 1010
-        "unknown", // 1011
-        "unknown", // 1012
-        "unknown", // 1013
-        "unknown", // 1014
-        "unknown", // 1015
-        "unknown", // 1016
-        "unknown", // 1017
-        "unknown", // 1018
-        "unknown", // 1019
-        "unknown", // 1020
-        "unknown", // 1021
-        "unknown", // 1022
-        "unknown", // 1023
-        "unknown", // 1024
-        "unknown", // 1025
-        "unknown", // 1026
-        "unknown", // 1027
-        "unknown", // 1028
-        "unknown", // 1029
-        "unknown", // 1030
-        "unknown", // 1031
-        "unknown", // 1032
-        "unknown", // 1033
-        "unknown", // 1034
-        "unknown", // 1035
-        "unknown", // 1036
-        "unknown", // 1037
-        "unknown", // 1038
-        "unknown", // 1039
-        "unknown", // 1040
-        "unknown", // 1041
-        "unknown", // 1042
-        "unknown", // 1043
-        "unknown", // 1044
-        "unknown", // 1045
-        "unknown", // 1046
-        "unknown", // 1047
-        "unknown", // 1048
-        "unknown", // 1049
-        "unknown", // 1050
-        "unknown", // 1051
-        "unknown", // 1052
-        "unknown", // 1053
-        "unknown", // 1054
-        "unknown", // 1055
-        "unknown", // 1056
-        "unknown", // 1057
-        "unknown", // 1058
-        "unknown", // 1059
-        "unknown", // 1060
-        "unknown", // 1061
-        "unknown", // 1062
-        "unknown", // 1063
-        "unknown", // 1064
-        "unknown", // 1065
-        "unknown", // 1066
-        "unknown", // 1067
-        "unknown", // 1068
-        "unknown", // 1069
-        "unknown", // 1070
-        "unknown", // 1071
-        "unknown", // 1072
-        "unknown", // 1073
-        "unknown", // 1074
-        "unknown", // 1075
-        "unknown", // 1076
-        "unknown", // 1077
-        "unknown", // 1078
-        "unknown", // 1079
-        "unknown", // 1080
-        "unknown", // 1081
-        "unknown", // 1082
-        "unknown", // 1083
-        "unknown", // 1084
-        "unknown", // 1085
-        "unknown", // 1086
-        "unknown", // 1087
-        "unknown", // 1088
-        "unknown", // 1089
-        "unknown", // 1090
-        "unknown", // 1091
-        "unknown", // 1092
-        "unknown", // 1093
-        "unknown", // 1094
-        "unknown", // 1095
-        "unknown", // 1096
-        "unknown", // 1097
-        "unknown", // 1098
-        "unknown", // 1099
-        "unknown", // 1100
-        "unknown", // 1101
-        "unknown", // 1102
-        "unknown", // 1103
-        "unknown", // 1104
-        "unknown", // 1105
-        "unknown", // 1106
-        "unknown", // 1107
-        "unknown", // 1108
-        "unknown", // 1109
-        "unknown", // 1110
-        "unknown", // 1111
-        "unknown", // 1112
-        "unknown", // 1113
-        "unknown", // 1114
-        "unknown", // 1115
-        "unknown", // 1116
-        "unknown", // 1117
-        "unknown", // 1118
-        "unknown", // 1119
-        "unknown", // 1120
-        "unknown", // 1121
-        "unknown", // 1122
-        "unknown", // 1123
-        "unknown", // 1124
-        "unknown", // 1125
-        "unknown", // 1126
-        "unknown", // 1127
-        "unknown", // 1128
-        "unknown", // 1129
-        "unknown", // 1130
-        "unknown", // 1131
-        "unknown", // 1132
-        "unknown", // 1133
-        "unknown", // 1134
-        "unknown", // 1135
-        "unknown", // 1136
-        "unknown", // 1137
-        "unknown", // 1138
-        "unknown", // 1139
-        "unknown", // 1140
-        "unknown", // 1141
-        "unknown", // 1142
-        "unknown", // 1143
-        "unknown", // 1144
-        "unknown", // 1145
-        "unknown", // 1146
-        "unknown", // 1147
-        "unknown", // 1148
-        "unknown", // 1149
-        "unknown", // 1150
-        "unknown", // 1151
-        "unknown", // 1152
-        "unknown", // 1153
-        "unknown", // 1154
-        "unknown", // 1155
-        "unknown", // 1156
-        "unknown", // 1157
-        "unknown", // 1158
-        "unknown", // 1159
-        "unknown", // 1160
-        "unknown", // 1161
-        "unknown", // 1162
-        "unknown", // 1163
-        "unknown", // 1164
-        "unknown", // 1165
-        "unknown", // 1166
-        "unknown", // 1167
-        "unknown", // 1168
-        "unknown", // 1169
-        "unknown", // 1170
-        "unknown", // 1171
-        "unknown", // 1172
-        "unknown", // 1173
-        "unknown", // 1174
-        "unknown", // 1175
-        "unknown", // 1176
-        "unknown", // 1177
-        "unknown", // 1178
-        "unknown", // 1179
-        "unknown", // 1180
-        "unknown", // 1181
-        "unknown", // 1182
-        "unknown", // 1183
-        "unknown", // 1184
-        "unknown", // 1185
-        "unknown", // 1186
-        "unknown", // 1187
-        "unknown", // 1188
-        "unknown", // 1189
-        "unknown", // 1190
-        "unknown", // 1191
-        "unknown", // 1192
-        "unknown", // 1193
-        "unknown", // 1194
-        "unknown", // 1195
-        "unknown", // 1196
-        "unknown", // 1197
-        "unknown", // 1198
-        "unknown", // 1199
-        "unknown", // 1200
-        "unknown", // 1201
-        "unknown", // 1202
-        "unknown", // 1203
-        "unknown", // 1204
-        "unknown", // 1205
-        "unknown", // 1206
-        "unknown", // 1207
-        "unknown", // 1208
-        "unknown", // 1209
-        "unknown", // 1210
-        "unknown", // 1211
-        "unknown", // 1212
-        "unknown", // 1213
-        "unknown", // 1214
-        "unknown", // 1215
-        "unknown", // 1216
-        "unknown", // 1217
-        "unknown", // 1218
-        "unknown", // 1219
-        "unknown", // 1220
-        "unknown", // 1221
-        "unknown", // 1222
-        "unknown", // 1223
-        "unknown", // 1224
-        "unknown", // 1225
-        "unknown", // 1226
-        "unknown", // 1227
-        "unknown", // 1228
-        "unknown", // 1229
-        "unknown", // 1230
-        "unknown", // 1231
-        "unknown", // 1232
-        "unknown", // 1233
-        "unknown", // 1234
-        "unknown", // 1235
-        "unknown", // 1236
-        "unknown", // 1237
-        "unknown", // 1238
-        "unknown", // 1239
-        "unknown", // 1240
-        "unknown", // 1241
-        "unknown", // 1242
-        "unknown", // 1243
-        "unknown", // 1244
-        "unknown", // 1245
-        "unknown", // 1246
-        "unknown", // 1247
-        "unknown", // 1248
-        "unknown", // 1249
-        "unknown", // 1250
-        "unknown", // 1251
-        "unknown", // 1252
-        "unknown", // 1253
-        "unknown", // 1254
-        "unknown", // 1255
-        "unknown", // 1256
-        "unknown", // 1257
-        "unknown", // 1258
-        "unknown", // 1259
-        "unknown", // 1260
-        "unknown", // 1261
-        "unknown", // 1262
-        "unknown", // 1263
-        "unknown", // 1264
-        "unknown", // 1265
-        "unknown", // 1266
-        "unknown", // 1267
-        "unknown", // 1268
-        "unknown", // 1269
-        "unknown", // 1270
-        "unknown", // 1271
-        "unknown", // 1272
-        "unknown", // 1273
-        "unknown", // 1274
-        "unknown", // 1275
-        "unknown", // 1276
-        "unknown", // 1277
-        "unknown", // 1278
-        "unknown", // 1279
-        "unknown", // 1280
-        "unknown", // 1281
-        "unknown", // 1282
-        "unknown", // 1283
-        "unknown", // 1284
-        "unknown", // 1285
-        "unknown", // 1286
-        "unknown", // 1287
-        "unknown", // 1288
-        "unknown", // 1289
-        "unknown", // 1290
-        "unknown", // 1291
-        "unknown", // 1292
-        "unknown", // 1293
-        "unknown", // 1294
-        "unknown", // 1295
-        "unknown", // 1296
-        "unknown", // 1297
-        "unknown", // 1298
-        "unknown", // 1299
-        "unknown", // 1300
-        "unknown", // 1301
-        "unknown", // 1302
-        "unknown", // 1303
-        "unknown", // 1304
-        "unknown", // 1305
-        "unknown", // 1306
-        "unknown", // 1307
-        "unknown", // 1308
-        "unknown", // 1309
-        "unknown", // 1310
-        "unknown", // 1311
-        "unknown", // 1312
-        "unknown", // 1313
-        "unknown", // 1314
-        "unknown", // 1315
-        "unknown", // 1316
-        "unknown", // 1317
-        "unknown", // 1318
-        "unknown", // 1319
-        "unknown", // 1320
-        "unknown", // 1321
-        "unknown", // 1322
-        "unknown", // 1323
-        "unknown", // 1324
-        "unknown", // 1325
-        "unknown", // 1326
-        "unknown", // 1327
-        "unknown", // 1328
-        "unknown", // 1329
-        "unknown", // 1330
-        "unknown", // 1331
-        "unknown", // 1332
-        "unknown", // 1333
-        "unknown", // 1334
-        "unknown", // 1335
-        "unknown", // 1336
-        "unknown", // 1337
-        "unknown", // 1338
-        "unknown", // 1339
-        "unknown", // 1340
-        "unknown", // 1341
-        "unknown", // 1342
-        "unknown", // 1343
-        "unknown", // 1344
-        "unknown", // 1345
-        "unknown", // 1346
-        "unknown", // 1347
-        "unknown", // 1348
-        "unknown", // 1349
-        "unknown", // 1350
-        "unknown", // 1351
-        "unknown", // 1352
-        "unknown", // 1353
-        "unknown", // 1354
-        "unknown", // 1355
-        "unknown", // 1356
-        "unknown", // 1357
-        "unknown", // 1358
-        "unknown", // 1359
-        "unknown", // 1360
-        "unknown", // 1361
-        "unknown", // 1362
-        "unknown", // 1363
-        "unknown", // 1364
-        "unknown", // 1365
-        "unknown", // 1366
-        "unknown", // 1367
-        "unknown", // 1368
-        "unknown", // 1369
-        "unknown", // 1370
-        "unknown", // 1371
-        "unknown", // 1372
-        "unknown", // 1373
-        "unknown", // 1374
-        "unknown", // 1375
-        "unknown", // 1376
-        "unknown", // 1377
-        "unknown", // 1378
-        "unknown", // 1379
-        "unknown", // 1380
-        "unknown", // 1381
-        "unknown", // 1382
-        "unknown", // 1383
-        "unknown", // 1384
-        "unknown", // 1385
-        "unknown", // 1386
-        "unknown", // 1387
-        "unknown", // 1388
-        "unknown", // 1389
-        "unknown", // 1390
-        "unknown", // 1391
-        "unknown", // 1392
-        "unknown", // 1393
-        "unknown", // 1394
-        "unknown", // 1395
-        "unknown", // 1396
-        "unknown", // 1397
-        "unknown", // 1398
-        "unknown", // 1399
-        "unknown", // 1400
-        "unknown", // 1401
-        "unknown", // 1402
-        "unknown", // 1403
-        "unknown", // 1404
-        "unknown", // 1405
-        "unknown", // 1406
-        "unknown", // 1407
-        "unknown", // 1408
-        "unknown", // 1409
-        "unknown", // 1410
-        "unknown", // 1411
-        "unknown", // 1412
-        "unknown", // 1413
-        "unknown", // 1414
-        "unknown", // 1415
-        "unknown", // 1416
-        "unknown", // 1417
-        "unknown", // 1418
-        "unknown", // 1419
-        "unknown", // 1420
-        "unknown", // 1421
-        "unknown", // 1422
-        "unknown", // 1423
-        "unknown", // 1424
-        "unknown", // 1425
-        "unknown", // 1426
-        "unknown", // 1427
-        "unknown", // 1428
-        "unknown", // 1429
-        "unknown", // 1430
-        "unknown", // 1431
-        "unknown", // 1432
-        "unknown", // 1433
-        "unknown", // 1434
-        "unknown", // 1435
-        "unknown", // 1436
-        "unknown", // 1437
-        "unknown", // 1438
-        "unknown", // 1439
-        "unknown", // 1440
-        "unknown", // 1441
-        "unknown", // 1442
-        "unknown", // 1443
-        "unknown", // 1444
-        "unknown", // 1445
-        "unknown", // 1446
-        "unknown", // 1447
-         "scontext", // 1448
-        "unknown", // 1449
-        "unknown", // 1450
-        "unknown", // 1451
-        "unknown", // 1452
-        "unknown", // 1453
-        "unknown", // 1454
-        "unknown", // 1455
-        "unknown", // 1456
-        "unknown", // 1457
-        "unknown", // 1458
-        "unknown", // 1459
-        "unknown", // 1460
-        "unknown", // 1461
-        "unknown", // 1462
-        "unknown", // 1463
-        "unknown", // 1464
-        "unknown", // 1465
-        "unknown", // 1466
-        "unknown", // 1467
-        "unknown", // 1468
-        "unknown", // 1469
-        "unknown", // 1470
-        "unknown", // 1471
-        "unknown", // 1472
-        "unknown", // 1473
-        "unknown", // 1474
-        "unknown", // 1475
-        "unknown", // 1476
-        "unknown", // 1477
-        "unknown", // 1478
-        "unknown", // 1479
-        "unknown", // 1480
-        "unknown", // 1481
-        "unknown", // 1482
-        "unknown", // 1483
-        "unknown", // 1484
-        "unknown", // 1485
-        "unknown", // 1486
-        "unknown", // 1487
-        "unknown", // 1488
-        "unknown", // 1489
-        "unknown", // 1490
-        "unknown", // 1491
-        "unknown", // 1492
-        "unknown", // 1493
-        "unknown", // 1494
-        "unknown", // 1495
-        "unknown", // 1496
-        "unknown", // 1497
-        "unknown", // 1498
-        "unknown", // 1499
-        "unknown", // 1500
-        "unknown", // 1501
-        "unknown", // 1502
-        "unknown", // 1503
-        "unknown", // 1504
-        "unknown", // 1505
-        "unknown", // 1506
-        "unknown", // 1507
-        "unknown", // 1508
-        "unknown", // 1509
-        "unknown", // 1510
-        "unknown", // 1511
-        "unknown", // 1512
-        "unknown", // 1513
-        "unknown", // 1514
-        "unknown", // 1515
-        "unknown", // 1516
-        "unknown", // 1517
-        "unknown", // 1518
-        "unknown", // 1519
-        "unknown", // 1520
-        "unknown", // 1521
-        "unknown", // 1522
-        "unknown", // 1523
-        "unknown", // 1524
-        "unknown", // 1525
-        "unknown", // 1526
-        "unknown", // 1527
-        "unknown", // 1528
-        "unknown", // 1529
-        "unknown", // 1530
-        "unknown", // 1531
-        "unknown", // 1532
-        "unknown", // 1533
-        "unknown", // 1534
-        "unknown", // 1535
-         "hstatus", // 1536
-        "unknown", // 1537
-         "hedeleg", // 1538
-         "hideleg", // 1539
-         "hie", // 1540
-         "htimedelta", // 1541
-         "hcounteren", // 1542
-         "hgeie", // 1543
-         "hvien", // 1544
-         "hvictl", // 1545
-         "henvcfg", // 1546
-        "unknown", // 1547
-         "hstateen0", // 1548
-         "hstateen1", // 1549
-         "hstateen2", // 1550
-         "hstateen3", // 1551
-        "unknown", // 1552
-        "unknown", // 1553
-        "unknown", // 1554
-         "hidelegh", // 1555
-        "unknown", // 1556
-         "htimedeltah", // 1557
-        "unknown", // 1558
-        "unknown", // 1559
-         "hvienh", // 1560
-        "unknown", // 1561
-         "henvcfgh", // 1562
-        "unknown", // 1563
-         "hstateen0h", // 1564
-         "hstateen1h", // 1565
-         "hstateen2h", // 1566
-         "hstateen3h", // 1567
-        "unknown", // 1568
-        "unknown", // 1569
-        "unknown", // 1570
-        "unknown", // 1571
-        "unknown", // 1572
-        "unknown", // 1573
-        "unknown", // 1574
-        "unknown", // 1575
-        "unknown", // 1576
-        "unknown", // 1577
-        "unknown", // 1578
-        "unknown", // 1579
-        "unknown", // 1580
-        "unknown", // 1581
-        "unknown", // 1582
-        "unknown", // 1583
-        "unknown", // 1584
-        "unknown", // 1585
-        "unknown", // 1586
-        "unknown", // 1587
-        "unknown", // 1588
-        "unknown", // 1589
-        "unknown", // 1590
-        "unknown", // 1591
-        "unknown", // 1592
-        "unknown", // 1593
-        "unknown", // 1594
-        "unknown", // 1595
-        "unknown", // 1596
-        "unknown", // 1597
-        "unknown", // 1598
-        "unknown", // 1599
-        "unknown", // 1600
-        "unknown", // 1601
-        "unknown", // 1602
-         "htval", // 1603
-         "hip", // 1604
-         "hvip", // 1605
-         "hviprio1", // 1606
-         "hviprio2", // 1607
-        "unknown", // 1608
-        "unknown", // 1609
-         "htinst", // 1610
-        "unknown", // 1611
-        "unknown", // 1612
-        "unknown", // 1613
-        "unknown", // 1614
-        "unknown", // 1615
-        "unknown", // 1616
-        "unknown", // 1617
-        "unknown", // 1618
-        "unknown", // 1619
-        "unknown", // 1620
-         "hviph", // 1621
-         "hviprio1h", // 1622
-         "hviprio2h", // 1623
-        "unknown", // 1624
-        "unknown", // 1625
-        "unknown", // 1626
-        "unknown", // 1627
-        "unknown", // 1628
-        "unknown", // 1629
-        "unknown", // 1630
-        "unknown", // 1631
-        "unknown", // 1632
-        "unknown", // 1633
-        "unknown", // 1634
-        "unknown", // 1635
-        "unknown", // 1636
-        "unknown", // 1637
-        "unknown", // 1638
-        "unknown", // 1639
-        "unknown", // 1640
-        "unknown", // 1641
-        "unknown", // 1642
-        "unknown", // 1643
-        "unknown", // 1644
-        "unknown", // 1645
-        "unknown", // 1646
-        "unknown", // 1647
-        "unknown", // 1648
-        "unknown", // 1649
-        "unknown", // 1650
-        "unknown", // 1651
-        "unknown", // 1652
-        "unknown", // 1653
-        "unknown", // 1654
-        "unknown", // 1655
-        "unknown", // 1656
-        "unknown", // 1657
-        "unknown", // 1658
-        "unknown", // 1659
-        "unknown", // 1660
-        "unknown", // 1661
-        "unknown", // 1662
-        "unknown", // 1663
-         "hgatp", // 1664
-        "unknown", // 1665
-        "unknown", // 1666
-        "unknown", // 1667
-        "unknown", // 1668
-        "unknown", // 1669
-        "unknown", // 1670
-        "unknown", // 1671
-        "unknown", // 1672
-        "unknown", // 1673
-        "unknown", // 1674
-        "unknown", // 1675
-        "unknown", // 1676
-        "unknown", // 1677
-        "unknown", // 1678
-        "unknown", // 1679
-        "unknown", // 1680
-        "unknown", // 1681
-        "unknown", // 1682
-        "unknown", // 1683
-        "unknown", // 1684
-        "unknown", // 1685
-        "unknown", // 1686
-        "unknown", // 1687
-        "unknown", // 1688
-        "unknown", // 1689
-        "unknown", // 1690
-        "unknown", // 1691
-        "unknown", // 1692
-        "unknown", // 1693
-        "unknown", // 1694
-        "unknown", // 1695
-        "unknown", // 1696
-        "unknown", // 1697
-        "unknown", // 1698
-        "unknown", // 1699
-        "unknown", // 1700
-        "unknown", // 1701
-        "unknown", // 1702
-        "unknown", // 1703
-         "hcontext", // 1704
-        "unknown", // 1705
-        "unknown", // 1706
-        "unknown", // 1707
-        "unknown", // 1708
-        "unknown", // 1709
-        "unknown", // 1710
-        "unknown", // 1711
-        "unknown", // 1712
-        "unknown", // 1713
-        "unknown", // 1714
-        "unknown", // 1715
-        "unknown", // 1716
-        "unknown", // 1717
-        "unknown", // 1718
-        "unknown", // 1719
-        "unknown", // 1720
-        "unknown", // 1721
-        "unknown", // 1722
-        "unknown", // 1723
-        "unknown", // 1724
-        "unknown", // 1725
-        "unknown", // 1726
-        "unknown", // 1727
-        "unknown", // 1728
-        "unknown", // 1729
-        "unknown", // 1730
-        "unknown", // 1731
-        "unknown", // 1732
-        "unknown", // 1733
-        "unknown", // 1734
-        "unknown", // 1735
-        "unknown", // 1736
-        "unknown", // 1737
-        "unknown", // 1738
-        "unknown", // 1739
-        "unknown", // 1740
-        "unknown", // 1741
-        "unknown", // 1742
-        "unknown", // 1743
-        "unknown", // 1744
-        "unknown", // 1745
-        "unknown", // 1746
-        "unknown", // 1747
-        "unknown", // 1748
-        "unknown", // 1749
-        "unknown", // 1750
-        "unknown", // 1751
-        "unknown", // 1752
-        "unknown", // 1753
-        "unknown", // 1754
-        "unknown", // 1755
-        "unknown", // 1756
-        "unknown", // 1757
-        "unknown", // 1758
-        "unknown", // 1759
-        "unknown", // 1760
-        "unknown", // 1761
-        "unknown", // 1762
-        "unknown", // 1763
-        "unknown", // 1764
-        "unknown", // 1765
-        "unknown", // 1766
-        "unknown", // 1767
-        "unknown", // 1768
-        "unknown", // 1769
-        "unknown", // 1770
-        "unknown", // 1771
-        "unknown", // 1772
-        "unknown", // 1773
-        "unknown", // 1774
-        "unknown", // 1775
-        "unknown", // 1776
-        "unknown", // 1777
-        "unknown", // 1778
-        "unknown", // 1779
-        "unknown", // 1780
-        "unknown", // 1781
-        "unknown", // 1782
-        "unknown", // 1783
-        "unknown", // 1784
-        "unknown", // 1785
-        "unknown", // 1786
-        "unknown", // 1787
-        "unknown", // 1788
-        "unknown", // 1789
-        "unknown", // 1790
-        "unknown", // 1791
-        "unknown", // 1792
-        "unknown", // 1793
-        "unknown", // 1794
-        "unknown", // 1795
-        "unknown", // 1796
-        "unknown", // 1797
-        "unknown", // 1798
-        "unknown", // 1799
-        "unknown", // 1800
-        "unknown", // 1801
-        "unknown", // 1802
-        "unknown", // 1803
-        "unknown", // 1804
-        "unknown", // 1805
-        "unknown", // 1806
-        "unknown", // 1807
-        "unknown", // 1808
-        "unknown", // 1809
-        "unknown", // 1810
-        "unknown", // 1811
-        "unknown", // 1812
-        "unknown", // 1813
-        "unknown", // 1814
-        "unknown", // 1815
-        "unknown", // 1816
-        "unknown", // 1817
-        "unknown", // 1818
-        "unknown", // 1819
-        "unknown", // 1820
-        "unknown", // 1821
-        "unknown", // 1822
-        "unknown", // 1823
-        "unknown", // 1824
-         "mcyclecfgh", // 1825
-         "minstretcfgh", // 1826
-         "mhpmevent3h", // 1827
-         "mhpmevent4h", // 1828
-         "mhpmevent5h", // 1829
-         "mhpmevent6h", // 1830
-         "mhpmevent7h", // 1831
-         "mhpmevent8h", // 1832
-         "mhpmevent9h", // 1833
-         "mhpmevent10h", // 1834
-         "mhpmevent11h", // 1835
-         "mhpmevent12h", // 1836
-         "mhpmevent13h", // 1837
-         "mhpmevent14h", // 1838
-         "mhpmevent15h", // 1839
-         "mhpmevent16h", // 1840
-         "mhpmevent17h", // 1841
-         "mhpmevent18h", // 1842
-         "mhpmevent19h", // 1843
-         "mhpmevent20h", // 1844
-         "mhpmevent21h", // 1845
-         "mhpmevent22h", // 1846
-         "mhpmevent23h", // 1847
-         "mhpmevent24h", // 1848
-         "mhpmevent25h", // 1849
-         "mhpmevent26h", // 1850
-         "mhpmevent27h", // 1851
-         "mhpmevent28h", // 1852
-         "mhpmevent29h", // 1853
-         "mhpmevent30h", // 1854
-         "mhpmevent31h", // 1855
-         "mnscratch", // 1856
-         "mnepc", // 1857
-         "mncause", // 1858
-        "unknown", // 1859
-         "mnstatus", // 1860
-        "unknown", // 1861
-        "unknown", // 1862
-         "mseccfg", // 1863
-        "unknown", // 1864
-        "unknown", // 1865
-        "unknown", // 1866
-        "unknown", // 1867
-        "unknown", // 1868
-        "unknown", // 1869
-        "unknown", // 1870
-        "unknown", // 1871
-        "unknown", // 1872
-        "unknown", // 1873
-        "unknown", // 1874
-        "unknown", // 1875
-        "unknown", // 1876
-        "unknown", // 1877
-        "unknown", // 1878
-         "mseccfgh", // 1879
-        "unknown", // 1880
-        "unknown", // 1881
-        "unknown", // 1882
-        "unknown", // 1883
-        "unknown", // 1884
-        "unknown", // 1885
-        "unknown", // 1886
-        "unknown", // 1887
-        "unknown", // 1888
-        "unknown", // 1889
-        "unknown", // 1890
-        "unknown", // 1891
-        "unknown", // 1892
-        "unknown", // 1893
-        "unknown", // 1894
-        "unknown", // 1895
-        "unknown", // 1896
-        "unknown", // 1897
-        "unknown", // 1898
-        "unknown", // 1899
-        "unknown", // 1900
-        "unknown", // 1901
-        "unknown", // 1902
-        "unknown", // 1903
-        "unknown", // 1904
-        "unknown", // 1905
-        "unknown", // 1906
-        "unknown", // 1907
-        "unknown", // 1908
-        "unknown", // 1909
-        "unknown", // 1910
-        "unknown", // 1911
-        "unknown", // 1912
-        "unknown", // 1913
-        "unknown", // 1914
-        "unknown", // 1915
-        "unknown", // 1916
-        "unknown", // 1917
-        "unknown", // 1918
-        "unknown", // 1919
-        "unknown", // 1920
-        "unknown", // 1921
-        "unknown", // 1922
-        "unknown", // 1923
-        "unknown", // 1924
-        "unknown", // 1925
-        "unknown", // 1926
-        "unknown", // 1927
-        "unknown", // 1928
-        "unknown", // 1929
-        "unknown", // 1930
-        "unknown", // 1931
-        "unknown", // 1932
-        "unknown", // 1933
-        "unknown", // 1934
-        "unknown", // 1935
-        "unknown", // 1936
-        "unknown", // 1937
-        "unknown", // 1938
-        "unknown", // 1939
-        "unknown", // 1940
-        "unknown", // 1941
-        "unknown", // 1942
-        "unknown", // 1943
-        "unknown", // 1944
-        "unknown", // 1945
-        "unknown", // 1946
-        "unknown", // 1947
-        "unknown", // 1948
-        "unknown", // 1949
-        "unknown", // 1950
-        "unknown", // 1951
-         "tselect", // 1952
-         "tdata1", // 1953
-         "tdata2", // 1954
-         "tdata3", // 1955
-         "tinfo", // 1956
-         "tcontrol", // 1957
-        "unknown", // 1958
-        "unknown", // 1959
-         "mcontext", // 1960
-        "unknown", // 1961
-         "mscontext", // 1962
-        "unknown", // 1963
-        "unknown", // 1964
-        "unknown", // 1965
-        "unknown", // 1966
-        "unknown", // 1967
-         "dcsr", // 1968
-         "dpc", // 1969
-         "dscratch0", // 1970
-         "dscratch1", // 1971
-        "unknown", // 1972
-        "unknown", // 1973
-        "unknown", // 1974
-        "unknown", // 1975
-        "unknown", // 1976
-        "unknown", // 1977
-        "unknown", // 1978
-        "unknown", // 1979
-        "unknown", // 1980
-        "unknown", // 1981
-        "unknown", // 1982
-        "unknown", // 1983
-        "unknown", // 1984
-        "unknown", // 1985
-        "unknown", // 1986
-        "unknown", // 1987
-        "unknown", // 1988
-        "unknown", // 1989
-        "unknown", // 1990
-        "unknown", // 1991
-        "unknown", // 1992
-        "unknown", // 1993
-        "unknown", // 1994
-        "unknown", // 1995
-        "unknown", // 1996
-        "unknown", // 1997
-        "unknown", // 1998
-        "unknown", // 1999
-        "unknown", // 2000
-        "unknown", // 2001
-        "unknown", // 2002
-        "unknown", // 2003
-        "unknown", // 2004
-        "unknown", // 2005
-        "unknown", // 2006
-        "unknown", // 2007
-        "unknown", // 2008
-        "unknown", // 2009
-        "unknown", // 2010
-        "unknown", // 2011
-        "unknown", // 2012
-        "unknown", // 2013
-        "unknown", // 2014
-        "unknown", // 2015
-        "unknown", // 2016
-        "unknown", // 2017
-        "unknown", // 2018
-        "unknown", // 2019
-        "unknown", // 2020
-        "unknown", // 2021
-        "unknown", // 2022
-        "unknown", // 2023
-        "unknown", // 2024
-        "unknown", // 2025
-        "unknown", // 2026
-        "unknown", // 2027
-        "unknown", // 2028
-        "unknown", // 2029
-        "unknown", // 2030
-        "unknown", // 2031
-        "unknown", // 2032
-        "unknown", // 2033
-        "unknown", // 2034
-        "unknown", // 2035
-        "unknown", // 2036
-        "unknown", // 2037
-        "unknown", // 2038
-        "unknown", // 2039
-        "unknown", // 2040
-        "unknown", // 2041
-        "unknown", // 2042
-        "unknown", // 2043
-        "unknown", // 2044
-        "unknown", // 2045
-        "unknown", // 2046
-        "unknown", // 2047
-        "unknown", // 2048
-        "unknown", // 2049
-        "unknown", // 2050
-        "unknown", // 2051
-        "unknown", // 2052
-        "unknown", // 2053
-        "unknown", // 2054
-        "unknown", // 2055
-        "unknown", // 2056
-        "unknown", // 2057
-        "unknown", // 2058
-        "unknown", // 2059
-        "unknown", // 2060
-        "unknown", // 2061
-        "unknown", // 2062
-        "unknown", // 2063
-        "unknown", // 2064
-        "unknown", // 2065
-        "unknown", // 2066
-        "unknown", // 2067
-        "unknown", // 2068
-        "unknown", // 2069
-        "unknown", // 2070
-        "unknown", // 2071
-        "unknown", // 2072
-        "unknown", // 2073
-        "unknown", // 2074
-        "unknown", // 2075
-        "unknown", // 2076
-        "unknown", // 2077
-        "unknown", // 2078
-        "unknown", // 2079
-        "unknown", // 2080
-        "unknown", // 2081
-        "unknown", // 2082
-        "unknown", // 2083
-        "unknown", // 2084
-        "unknown", // 2085
-        "unknown", // 2086
-        "unknown", // 2087
-        "unknown", // 2088
-        "unknown", // 2089
-        "unknown", // 2090
-        "unknown", // 2091
-        "unknown", // 2092
-        "unknown", // 2093
-        "unknown", // 2094
-        "unknown", // 2095
-        "unknown", // 2096
-        "unknown", // 2097
-        "unknown", // 2098
-        "unknown", // 2099
-        "unknown", // 2100
-        "unknown", // 2101
-        "unknown", // 2102
-        "unknown", // 2103
-        "unknown", // 2104
-        "unknown", // 2105
-        "unknown", // 2106
-        "unknown", // 2107
-        "unknown", // 2108
-        "unknown", // 2109
-        "unknown", // 2110
-        "unknown", // 2111
-        "unknown", // 2112
-        "unknown", // 2113
-        "unknown", // 2114
-        "unknown", // 2115
-        "unknown", // 2116
-        "unknown", // 2117
-        "unknown", // 2118
-        "unknown", // 2119
-        "unknown", // 2120
-        "unknown", // 2121
-        "unknown", // 2122
-        "unknown", // 2123
-        "unknown", // 2124
-        "unknown", // 2125
-        "unknown", // 2126
-        "unknown", // 2127
-        "unknown", // 2128
-        "unknown", // 2129
-        "unknown", // 2130
-        "unknown", // 2131
-        "unknown", // 2132
-        "unknown", // 2133
-        "unknown", // 2134
-        "unknown", // 2135
-        "unknown", // 2136
-        "unknown", // 2137
-        "unknown", // 2138
-        "unknown", // 2139
-        "unknown", // 2140
-        "unknown", // 2141
-        "unknown", // 2142
-        "unknown", // 2143
-        "unknown", // 2144
-        "unknown", // 2145
-        "unknown", // 2146
-        "unknown", // 2147
-        "unknown", // 2148
-        "unknown", // 2149
-        "unknown", // 2150
-        "unknown", // 2151
-        "unknown", // 2152
-        "unknown", // 2153
-        "unknown", // 2154
-        "unknown", // 2155
-        "unknown", // 2156
-        "unknown", // 2157
-        "unknown", // 2158
-        "unknown", // 2159
-        "unknown", // 2160
-        "unknown", // 2161
-        "unknown", // 2162
-        "unknown", // 2163
-        "unknown", // 2164
-        "unknown", // 2165
-        "unknown", // 2166
-        "unknown", // 2167
-        "unknown", // 2168
-        "unknown", // 2169
-        "unknown", // 2170
-        "unknown", // 2171
-        "unknown", // 2172
-        "unknown", // 2173
-        "unknown", // 2174
-        "unknown", // 2175
-        "unknown", // 2176
-        "unknown", // 2177
-        "unknown", // 2178
-        "unknown", // 2179
-        "unknown", // 2180
-        "unknown", // 2181
-        "unknown", // 2182
-        "unknown", // 2183
-        "unknown", // 2184
-        "unknown", // 2185
-        "unknown", // 2186
-        "unknown", // 2187
-        "unknown", // 2188
-        "unknown", // 2189
-        "unknown", // 2190
-        "unknown", // 2191
-        "unknown", // 2192
-        "unknown", // 2193
-        "unknown", // 2194
-        "unknown", // 2195
-        "unknown", // 2196
-        "unknown", // 2197
-        "unknown", // 2198
-        "unknown", // 2199
-        "unknown", // 2200
-        "unknown", // 2201
-        "unknown", // 2202
-        "unknown", // 2203
-        "unknown", // 2204
-        "unknown", // 2205
-        "unknown", // 2206
-        "unknown", // 2207
-        "unknown", // 2208
-        "unknown", // 2209
-        "unknown", // 2210
-        "unknown", // 2211
-        "unknown", // 2212
-        "unknown", // 2213
-        "unknown", // 2214
-        "unknown", // 2215
-        "unknown", // 2216
-        "unknown", // 2217
-        "unknown", // 2218
-        "unknown", // 2219
-        "unknown", // 2220
-        "unknown", // 2221
-        "unknown", // 2222
-        "unknown", // 2223
-        "unknown", // 2224
-        "unknown", // 2225
-        "unknown", // 2226
-        "unknown", // 2227
-        "unknown", // 2228
-        "unknown", // 2229
-        "unknown", // 2230
-        "unknown", // 2231
-        "unknown", // 2232
-        "unknown", // 2233
-        "unknown", // 2234
-        "unknown", // 2235
-        "unknown", // 2236
-        "unknown", // 2237
-        "unknown", // 2238
-        "unknown", // 2239
-        "unknown", // 2240
-        "unknown", // 2241
-        "unknown", // 2242
-        "unknown", // 2243
-        "unknown", // 2244
-        "unknown", // 2245
-        "unknown", // 2246
-        "unknown", // 2247
-        "unknown", // 2248
-        "unknown", // 2249
-        "unknown", // 2250
-        "unknown", // 2251
-        "unknown", // 2252
-        "unknown", // 2253
-        "unknown", // 2254
-        "unknown", // 2255
-        "unknown", // 2256
-        "unknown", // 2257
-        "unknown", // 2258
-        "unknown", // 2259
-        "unknown", // 2260
-        "unknown", // 2261
-        "unknown", // 2262
-        "unknown", // 2263
-        "unknown", // 2264
-        "unknown", // 2265
-        "unknown", // 2266
-        "unknown", // 2267
-        "unknown", // 2268
-        "unknown", // 2269
-        "unknown", // 2270
-        "unknown", // 2271
-        "unknown", // 2272
-        "unknown", // 2273
-        "unknown", // 2274
-        "unknown", // 2275
-        "unknown", // 2276
-        "unknown", // 2277
-        "unknown", // 2278
-        "unknown", // 2279
-        "unknown", // 2280
-        "unknown", // 2281
-        "unknown", // 2282
-        "unknown", // 2283
-        "unknown", // 2284
-        "unknown", // 2285
-        "unknown", // 2286
-        "unknown", // 2287
-        "unknown", // 2288
-        "unknown", // 2289
-        "unknown", // 2290
-        "unknown", // 2291
-        "unknown", // 2292
-        "unknown", // 2293
-        "unknown", // 2294
-        "unknown", // 2295
-        "unknown", // 2296
-        "unknown", // 2297
-        "unknown", // 2298
-        "unknown", // 2299
-        "unknown", // 2300
-        "unknown", // 2301
-        "unknown", // 2302
-        "unknown", // 2303
-        "unknown", // 2304
-        "unknown", // 2305
-        "unknown", // 2306
-        "unknown", // 2307
-        "unknown", // 2308
-        "unknown", // 2309
-        "unknown", // 2310
-        "unknown", // 2311
-        "unknown", // 2312
-        "unknown", // 2313
-        "unknown", // 2314
-        "unknown", // 2315
-        "unknown", // 2316
-        "unknown", // 2317
-        "unknown", // 2318
-        "unknown", // 2319
-        "unknown", // 2320
-        "unknown", // 2321
-        "unknown", // 2322
-        "unknown", // 2323
-        "unknown", // 2324
-        "unknown", // 2325
-        "unknown", // 2326
-        "unknown", // 2327
-        "unknown", // 2328
-        "unknown", // 2329
-        "unknown", // 2330
-        "unknown", // 2331
-        "unknown", // 2332
-        "unknown", // 2333
-        "unknown", // 2334
-        "unknown", // 2335
-        "unknown", // 2336
-        "unknown", // 2337
-        "unknown", // 2338
-        "unknown", // 2339
-        "unknown", // 2340
-        "unknown", // 2341
-        "unknown", // 2342
-        "unknown", // 2343
-        "unknown", // 2344
-        "unknown", // 2345
-        "unknown", // 2346
-        "unknown", // 2347
-        "unknown", // 2348
-        "unknown", // 2349
-        "unknown", // 2350
-        "unknown", // 2351
-        "unknown", // 2352
-        "unknown", // 2353
-        "unknown", // 2354
-        "unknown", // 2355
-        "unknown", // 2356
-        "unknown", // 2357
-        "unknown", // 2358
-        "unknown", // 2359
-        "unknown", // 2360
-        "unknown", // 2361
-        "unknown", // 2362
-        "unknown", // 2363
-        "unknown", // 2364
-        "unknown", // 2365
-        "unknown", // 2366
-        "unknown", // 2367
-        "unknown", // 2368
-        "unknown", // 2369
-        "unknown", // 2370
-        "unknown", // 2371
-        "unknown", // 2372
-        "unknown", // 2373
-        "unknown", // 2374
-        "unknown", // 2375
-        "unknown", // 2376
-        "unknown", // 2377
-        "unknown", // 2378
-        "unknown", // 2379
-        "unknown", // 2380
-        "unknown", // 2381
-        "unknown", // 2382
-        "unknown", // 2383
-        "unknown", // 2384
-        "unknown", // 2385
-        "unknown", // 2386
-        "unknown", // 2387
-        "unknown", // 2388
-        "unknown", // 2389
-        "unknown", // 2390
-        "unknown", // 2391
-        "unknown", // 2392
-        "unknown", // 2393
-        "unknown", // 2394
-        "unknown", // 2395
-        "unknown", // 2396
-        "unknown", // 2397
-        "unknown", // 2398
-        "unknown", // 2399
-        "unknown", // 2400
-        "unknown", // 2401
-        "unknown", // 2402
-        "unknown", // 2403
-        "unknown", // 2404
-        "unknown", // 2405
-        "unknown", // 2406
-        "unknown", // 2407
-        "unknown", // 2408
-        "unknown", // 2409
-        "unknown", // 2410
-        "unknown", // 2411
-        "unknown", // 2412
-        "unknown", // 2413
-        "unknown", // 2414
-        "unknown", // 2415
-        "unknown", // 2416
-        "unknown", // 2417
-        "unknown", // 2418
-        "unknown", // 2419
-        "unknown", // 2420
-        "unknown", // 2421
-        "unknown", // 2422
-        "unknown", // 2423
-        "unknown", // 2424
-        "unknown", // 2425
-        "unknown", // 2426
-        "unknown", // 2427
-        "unknown", // 2428
-        "unknown", // 2429
-        "unknown", // 2430
-        "unknown", // 2431
-        "unknown", // 2432
-        "unknown", // 2433
-        "unknown", // 2434
-        "unknown", // 2435
-        "unknown", // 2436
-        "unknown", // 2437
-        "unknown", // 2438
-        "unknown", // 2439
-        "unknown", // 2440
-        "unknown", // 2441
-        "unknown", // 2442
-        "unknown", // 2443
-        "unknown", // 2444
-        "unknown", // 2445
-        "unknown", // 2446
-        "unknown", // 2447
-        "unknown", // 2448
-        "unknown", // 2449
-        "unknown", // 2450
-        "unknown", // 2451
-        "unknown", // 2452
-        "unknown", // 2453
-        "unknown", // 2454
-        "unknown", // 2455
-        "unknown", // 2456
-        "unknown", // 2457
-        "unknown", // 2458
-        "unknown", // 2459
-        "unknown", // 2460
-        "unknown", // 2461
-        "unknown", // 2462
-        "unknown", // 2463
-        "unknown", // 2464
-        "unknown", // 2465
-        "unknown", // 2466
-        "unknown", // 2467
-        "unknown", // 2468
-        "unknown", // 2469
-        "unknown", // 2470
-        "unknown", // 2471
-        "unknown", // 2472
-        "unknown", // 2473
-        "unknown", // 2474
-        "unknown", // 2475
-        "unknown", // 2476
-        "unknown", // 2477
-        "unknown", // 2478
-        "unknown", // 2479
-        "unknown", // 2480
-        "unknown", // 2481
-        "unknown", // 2482
-        "unknown", // 2483
-        "unknown", // 2484
-        "unknown", // 2485
-        "unknown", // 2486
-        "unknown", // 2487
-        "unknown", // 2488
-        "unknown", // 2489
-        "unknown", // 2490
-        "unknown", // 2491
-        "unknown", // 2492
-        "unknown", // 2493
-        "unknown", // 2494
-        "unknown", // 2495
-        "unknown", // 2496
-        "unknown", // 2497
-        "unknown", // 2498
-        "unknown", // 2499
-        "unknown", // 2500
-        "unknown", // 2501
-        "unknown", // 2502
-        "unknown", // 2503
-        "unknown", // 2504
-        "unknown", // 2505
-        "unknown", // 2506
-        "unknown", // 2507
-        "unknown", // 2508
-        "unknown", // 2509
-        "unknown", // 2510
-        "unknown", // 2511
-        "unknown", // 2512
-        "unknown", // 2513
-        "unknown", // 2514
-        "unknown", // 2515
-        "unknown", // 2516
-        "unknown", // 2517
-        "unknown", // 2518
-        "unknown", // 2519
-        "unknown", // 2520
-        "unknown", // 2521
-        "unknown", // 2522
-        "unknown", // 2523
-        "unknown", // 2524
-        "unknown", // 2525
-        "unknown", // 2526
-        "unknown", // 2527
-        "unknown", // 2528
-        "unknown", // 2529
-        "unknown", // 2530
-        "unknown", // 2531
-        "unknown", // 2532
-        "unknown", // 2533
-        "unknown", // 2534
-        "unknown", // 2535
-        "unknown", // 2536
-        "unknown", // 2537
-        "unknown", // 2538
-        "unknown", // 2539
-        "unknown", // 2540
-        "unknown", // 2541
-        "unknown", // 2542
-        "unknown", // 2543
-        "unknown", // 2544
-        "unknown", // 2545
-        "unknown", // 2546
-        "unknown", // 2547
-        "unknown", // 2548
-        "unknown", // 2549
-        "unknown", // 2550
-        "unknown", // 2551
-        "unknown", // 2552
-        "unknown", // 2553
-        "unknown", // 2554
-        "unknown", // 2555
-        "unknown", // 2556
-        "unknown", // 2557
-        "unknown", // 2558
-        "unknown", // 2559
-        "unknown", // 2560
-        "unknown", // 2561
-        "unknown", // 2562
-        "unknown", // 2563
-        "unknown", // 2564
-        "unknown", // 2565
-        "unknown", // 2566
-        "unknown", // 2567
-        "unknown", // 2568
-        "unknown", // 2569
-        "unknown", // 2570
-        "unknown", // 2571
-        "unknown", // 2572
-        "unknown", // 2573
-        "unknown", // 2574
-        "unknown", // 2575
-        "unknown", // 2576
-        "unknown", // 2577
-        "unknown", // 2578
-        "unknown", // 2579
-        "unknown", // 2580
-        "unknown", // 2581
-        "unknown", // 2582
-        "unknown", // 2583
-        "unknown", // 2584
-        "unknown", // 2585
-        "unknown", // 2586
-        "unknown", // 2587
-        "unknown", // 2588
-        "unknown", // 2589
-        "unknown", // 2590
-        "unknown", // 2591
-        "unknown", // 2592
-        "unknown", // 2593
-        "unknown", // 2594
-        "unknown", // 2595
-        "unknown", // 2596
-        "unknown", // 2597
-        "unknown", // 2598
-        "unknown", // 2599
-        "unknown", // 2600
-        "unknown", // 2601
-        "unknown", // 2602
-        "unknown", // 2603
-        "unknown", // 2604
-        "unknown", // 2605
-        "unknown", // 2606
-        "unknown", // 2607
-        "unknown", // 2608
-        "unknown", // 2609
-        "unknown", // 2610
-        "unknown", // 2611
-        "unknown", // 2612
-        "unknown", // 2613
-        "unknown", // 2614
-        "unknown", // 2615
-        "unknown", // 2616
-        "unknown", // 2617
-        "unknown", // 2618
-        "unknown", // 2619
-        "unknown", // 2620
-        "unknown", // 2621
-        "unknown", // 2622
-        "unknown", // 2623
-        "unknown", // 2624
-        "unknown", // 2625
-        "unknown", // 2626
-        "unknown", // 2627
-        "unknown", // 2628
-        "unknown", // 2629
-        "unknown", // 2630
-        "unknown", // 2631
-        "unknown", // 2632
-        "unknown", // 2633
-        "unknown", // 2634
-        "unknown", // 2635
-        "unknown", // 2636
-        "unknown", // 2637
-        "unknown", // 2638
-        "unknown", // 2639
-        "unknown", // 2640
-        "unknown", // 2641
-        "unknown", // 2642
-        "unknown", // 2643
-        "unknown", // 2644
-        "unknown", // 2645
-        "unknown", // 2646
-        "unknown", // 2647
-        "unknown", // 2648
-        "unknown", // 2649
-        "unknown", // 2650
-        "unknown", // 2651
-        "unknown", // 2652
-        "unknown", // 2653
-        "unknown", // 2654
-        "unknown", // 2655
-        "unknown", // 2656
-        "unknown", // 2657
-        "unknown", // 2658
-        "unknown", // 2659
-        "unknown", // 2660
-        "unknown", // 2661
-        "unknown", // 2662
-        "unknown", // 2663
-        "unknown", // 2664
-        "unknown", // 2665
-        "unknown", // 2666
-        "unknown", // 2667
-        "unknown", // 2668
-        "unknown", // 2669
-        "unknown", // 2670
-        "unknown", // 2671
-        "unknown", // 2672
-        "unknown", // 2673
-        "unknown", // 2674
-        "unknown", // 2675
-        "unknown", // 2676
-        "unknown", // 2677
-        "unknown", // 2678
-        "unknown", // 2679
-        "unknown", // 2680
-        "unknown", // 2681
-        "unknown", // 2682
-        "unknown", // 2683
-        "unknown", // 2684
-        "unknown", // 2685
-        "unknown", // 2686
-        "unknown", // 2687
-        "unknown", // 2688
-        "unknown", // 2689
-        "unknown", // 2690
-        "unknown", // 2691
-        "unknown", // 2692
-        "unknown", // 2693
-        "unknown", // 2694
-        "unknown", // 2695
-        "unknown", // 2696
-        "unknown", // 2697
-        "unknown", // 2698
-        "unknown", // 2699
-        "unknown", // 2700
-        "unknown", // 2701
-        "unknown", // 2702
-        "unknown", // 2703
-        "unknown", // 2704
-        "unknown", // 2705
-        "unknown", // 2706
-        "unknown", // 2707
-        "unknown", // 2708
-        "unknown", // 2709
-        "unknown", // 2710
-        "unknown", // 2711
-        "unknown", // 2712
-        "unknown", // 2713
-        "unknown", // 2714
-        "unknown", // 2715
-        "unknown", // 2716
-        "unknown", // 2717
-        "unknown", // 2718
-        "unknown", // 2719
-        "unknown", // 2720
-        "unknown", // 2721
-        "unknown", // 2722
-        "unknown", // 2723
-        "unknown", // 2724
-        "unknown", // 2725
-        "unknown", // 2726
-        "unknown", // 2727
-        "unknown", // 2728
-        "unknown", // 2729
-        "unknown", // 2730
-        "unknown", // 2731
-        "unknown", // 2732
-        "unknown", // 2733
-        "unknown", // 2734
-        "unknown", // 2735
-        "unknown", // 2736
-        "unknown", // 2737
-        "unknown", // 2738
-        "unknown", // 2739
-        "unknown", // 2740
-        "unknown", // 2741
-        "unknown", // 2742
-        "unknown", // 2743
-        "unknown", // 2744
-        "unknown", // 2745
-        "unknown", // 2746
-        "unknown", // 2747
-        "unknown", // 2748
-        "unknown", // 2749
-        "unknown", // 2750
-        "unknown", // 2751
-        "unknown", // 2752
-        "unknown", // 2753
-        "unknown", // 2754
-        "unknown", // 2755
-        "unknown", // 2756
-        "unknown", // 2757
-        "unknown", // 2758
-        "unknown", // 2759
-        "unknown", // 2760
-        "unknown", // 2761
-        "unknown", // 2762
-        "unknown", // 2763
-        "unknown", // 2764
-        "unknown", // 2765
-        "unknown", // 2766
-        "unknown", // 2767
-        "unknown", // 2768
-        "unknown", // 2769
-        "unknown", // 2770
-        "unknown", // 2771
-        "unknown", // 2772
-        "unknown", // 2773
-        "unknown", // 2774
-        "unknown", // 2775
-        "unknown", // 2776
-        "unknown", // 2777
-        "unknown", // 2778
-        "unknown", // 2779
-        "unknown", // 2780
-        "unknown", // 2781
-        "unknown", // 2782
-        "unknown", // 2783
-        "unknown", // 2784
-        "unknown", // 2785
-        "unknown", // 2786
-        "unknown", // 2787
-        "unknown", // 2788
-        "unknown", // 2789
-        "unknown", // 2790
-        "unknown", // 2791
-        "unknown", // 2792
-        "unknown", // 2793
-        "unknown", // 2794
-        "unknown", // 2795
-        "unknown", // 2796
-        "unknown", // 2797
-        "unknown", // 2798
-        "unknown", // 2799
-        "unknown", // 2800
-        "unknown", // 2801
-        "unknown", // 2802
-        "unknown", // 2803
-        "unknown", // 2804
-        "unknown", // 2805
-        "unknown", // 2806
-        "unknown", // 2807
-        "unknown", // 2808
-        "unknown", // 2809
-        "unknown", // 2810
-        "unknown", // 2811
-        "unknown", // 2812
-        "unknown", // 2813
-        "unknown", // 2814
-        "unknown", // 2815
-         "mcycle", // 2816
-        "unknown", // 2817
-         "minstret", // 2818
-         "mhpmcounter3", // 2819
-         "mhpmcounter4", // 2820
-         "mhpmcounter5", // 2821
-         "mhpmcounter6", // 2822
-         "mhpmcounter7", // 2823
-         "mhpmcounter8", // 2824
-         "mhpmcounter9", // 2825
-         "mhpmcounter10", // 2826
-         "mhpmcounter11", // 2827
-         "mhpmcounter12", // 2828
-         "mhpmcounter13", // 2829
-         "mhpmcounter14", // 2830
-         "mhpmcounter15", // 2831
-         "mhpmcounter16", // 2832
-         "mhpmcounter17", // 2833
-         "mhpmcounter18", // 2834
-         "mhpmcounter19", // 2835
-         "mhpmcounter20", // 2836
-         "mhpmcounter21", // 2837
-         "mhpmcounter22", // 2838
-         "mhpmcounter23", // 2839
-         "mhpmcounter24", // 2840
-         "mhpmcounter25", // 2841
-         "mhpmcounter26", // 2842
-         "mhpmcounter27", // 2843
-         "mhpmcounter28", // 2844
-         "mhpmcounter29", // 2845
-         "mhpmcounter30", // 2846
-         "mhpmcounter31", // 2847
-        "unknown", // 2848
-        "unknown", // 2849
-        "unknown", // 2850
-        "unknown", // 2851
-        "unknown", // 2852
-        "unknown", // 2853
-        "unknown", // 2854
-        "unknown", // 2855
-        "unknown", // 2856
-        "unknown", // 2857
-        "unknown", // 2858
-        "unknown", // 2859
-        "unknown", // 2860
-        "unknown", // 2861
-        "unknown", // 2862
-        "unknown", // 2863
-        "unknown", // 2864
-        "unknown", // 2865
-        "unknown", // 2866
-        "unknown", // 2867
-        "unknown", // 2868
-        "unknown", // 2869
-        "unknown", // 2870
-        "unknown", // 2871
-        "unknown", // 2872
-        "unknown", // 2873
-        "unknown", // 2874
-        "unknown", // 2875
-        "unknown", // 2876
-        "unknown", // 2877
-        "unknown", // 2878
-        "unknown", // 2879
-        "unknown", // 2880
-        "unknown", // 2881
-        "unknown", // 2882
-        "unknown", // 2883
-        "unknown", // 2884
-        "unknown", // 2885
-        "unknown", // 2886
-        "unknown", // 2887
-        "unknown", // 2888
-        "unknown", // 2889
-        "unknown", // 2890
-        "unknown", // 2891
-        "unknown", // 2892
-        "unknown", // 2893
-        "unknown", // 2894
-        "unknown", // 2895
-        "unknown", // 2896
-        "unknown", // 2897
-        "unknown", // 2898
-        "unknown", // 2899
-        "unknown", // 2900
-        "unknown", // 2901
-        "unknown", // 2902
-        "unknown", // 2903
-        "unknown", // 2904
-        "unknown", // 2905
-        "unknown", // 2906
-        "unknown", // 2907
-        "unknown", // 2908
-        "unknown", // 2909
-        "unknown", // 2910
-        "unknown", // 2911
-        "unknown", // 2912
-        "unknown", // 2913
-        "unknown", // 2914
-        "unknown", // 2915
-        "unknown", // 2916
-        "unknown", // 2917
-        "unknown", // 2918
-        "unknown", // 2919
-        "unknown", // 2920
-        "unknown", // 2921
-        "unknown", // 2922
-        "unknown", // 2923
-        "unknown", // 2924
-        "unknown", // 2925
-        "unknown", // 2926
-        "unknown", // 2927
-        "unknown", // 2928
-        "unknown", // 2929
-        "unknown", // 2930
-        "unknown", // 2931
-        "unknown", // 2932
-        "unknown", // 2933
-        "unknown", // 2934
-        "unknown", // 2935
-        "unknown", // 2936
-        "unknown", // 2937
-        "unknown", // 2938
-        "unknown", // 2939
-        "unknown", // 2940
-        "unknown", // 2941
-        "unknown", // 2942
-        "unknown", // 2943
-         "mcycleh", // 2944
-        "unknown", // 2945
-         "minstreth", // 2946
-         "mhpmcounter3h", // 2947
-         "mhpmcounter4h", // 2948
-         "mhpmcounter5h", // 2949
-         "mhpmcounter6h", // 2950
-         "mhpmcounter7h", // 2951
-         "mhpmcounter8h", // 2952
-         "mhpmcounter9h", // 2953
-         "mhpmcounter10h", // 2954
-         "mhpmcounter11h", // 2955
-         "mhpmcounter12h", // 2956
-         "mhpmcounter13h", // 2957
-         "mhpmcounter14h", // 2958
-         "mhpmcounter15h", // 2959
-         "mhpmcounter16h", // 2960
-         "mhpmcounter17h", // 2961
-         "mhpmcounter18h", // 2962
-         "mhpmcounter19h", // 2963
-         "mhpmcounter20h", // 2964
-         "mhpmcounter21h", // 2965
-         "mhpmcounter22h", // 2966
-         "mhpmcounter23h", // 2967
-         "mhpmcounter24h", // 2968
-         "mhpmcounter25h", // 2969
-         "mhpmcounter26h", // 2970
-         "mhpmcounter27h", // 2971
-         "mhpmcounter28h", // 2972
-         "mhpmcounter29h", // 2973
-         "mhpmcounter30h", // 2974
-         "mhpmcounter31h", // 2975
-        "unknown", // 2976
-        "unknown", // 2977
-        "unknown", // 2978
-        "unknown", // 2979
-        "unknown", // 2980
-        "unknown", // 2981
-        "unknown", // 2982
-        "unknown", // 2983
-        "unknown", // 2984
-        "unknown", // 2985
-        "unknown", // 2986
-        "unknown", // 2987
-        "unknown", // 2988
-        "unknown", // 2989
-        "unknown", // 2990
-        "unknown", // 2991
-        "unknown", // 2992
-        "unknown", // 2993
-        "unknown", // 2994
-        "unknown", // 2995
-        "unknown", // 2996
-        "unknown", // 2997
-        "unknown", // 2998
-        "unknown", // 2999
-        "unknown", // 3000
-        "unknown", // 3001
-        "unknown", // 3002
-        "unknown", // 3003
-        "unknown", // 3004
-        "unknown", // 3005
-        "unknown", // 3006
-        "unknown", // 3007
-        "unknown", // 3008
-        "unknown", // 3009
-        "unknown", // 3010
-        "unknown", // 3011
-        "unknown", // 3012
-        "unknown", // 3013
-        "unknown", // 3014
-        "unknown", // 3015
-        "unknown", // 3016
-        "unknown", // 3017
-        "unknown", // 3018
-        "unknown", // 3019
-        "unknown", // 3020
-        "unknown", // 3021
-        "unknown", // 3022
-        "unknown", // 3023
-        "unknown", // 3024
-        "unknown", // 3025
-        "unknown", // 3026
-        "unknown", // 3027
-        "unknown", // 3028
-        "unknown", // 3029
-        "unknown", // 3030
-        "unknown", // 3031
-        "unknown", // 3032
-        "unknown", // 3033
-        "unknown", // 3034
-        "unknown", // 3035
-        "unknown", // 3036
-        "unknown", // 3037
-        "unknown", // 3038
-        "unknown", // 3039
-        "unknown", // 3040
-        "unknown", // 3041
-        "unknown", // 3042
-        "unknown", // 3043
-        "unknown", // 3044
-        "unknown", // 3045
-        "unknown", // 3046
-        "unknown", // 3047
-        "unknown", // 3048
-        "unknown", // 3049
-        "unknown", // 3050
-        "unknown", // 3051
-        "unknown", // 3052
-        "unknown", // 3053
-        "unknown", // 3054
-        "unknown", // 3055
-        "unknown", // 3056
-        "unknown", // 3057
-        "unknown", // 3058
-        "unknown", // 3059
-        "unknown", // 3060
-        "unknown", // 3061
-        "unknown", // 3062
-        "unknown", // 3063
-        "unknown", // 3064
-        "unknown", // 3065
-        "unknown", // 3066
-        "unknown", // 3067
-        "unknown", // 3068
-        "unknown", // 3069
-        "unknown", // 3070
-        "unknown", // 3071
-         "cycle", // 3072
-         "time", // 3073
-         "instret", // 3074
-         "hpmcounter3", // 3075
-         "hpmcounter4", // 3076
-         "hpmcounter5", // 3077
-         "hpmcounter6", // 3078
-         "hpmcounter7", // 3079
-         "hpmcounter8", // 3080
-         "hpmcounter9", // 3081
-         "hpmcounter10", // 3082
-         "hpmcounter11", // 3083
-         "hpmcounter12", // 3084
-         "hpmcounter13", // 3085
-         "hpmcounter14", // 3086
-         "hpmcounter15", // 3087
-         "hpmcounter16", // 3088
-         "hpmcounter17", // 3089
-         "hpmcounter18", // 3090
-         "hpmcounter19", // 3091
-         "hpmcounter20", // 3092
-         "hpmcounter21", // 3093
-         "hpmcounter22", // 3094
-         "hpmcounter23", // 3095
-         "hpmcounter24", // 3096
-         "hpmcounter25", // 3097
-         "hpmcounter26", // 3098
-         "hpmcounter27", // 3099
-         "hpmcounter28", // 3100
-         "hpmcounter29", // 3101
-         "hpmcounter30", // 3102
-         "hpmcounter31", // 3103
-         "vl", // 3104
-         "vtype", // 3105
-         "vlenb", // 3106
-        "unknown", // 3107
-        "unknown", // 3108
-        "unknown", // 3109
-        "unknown", // 3110
-        "unknown", // 3111
-        "unknown", // 3112
-        "unknown", // 3113
-        "unknown", // 3114
-        "unknown", // 3115
-        "unknown", // 3116
-        "unknown", // 3117
-        "unknown", // 3118
-        "unknown", // 3119
-        "unknown", // 3120
-        "unknown", // 3121
-        "unknown", // 3122
-        "unknown", // 3123
-        "unknown", // 3124
-        "unknown", // 3125
-        "unknown", // 3126
-        "unknown", // 3127
-        "unknown", // 3128
-        "unknown", // 3129
-        "unknown", // 3130
-        "unknown", // 3131
-        "unknown", // 3132
-        "unknown", // 3133
-        "unknown", // 3134
-        "unknown", // 3135
-        "unknown", // 3136
-        "unknown", // 3137
-        "unknown", // 3138
-        "unknown", // 3139
-        "unknown", // 3140
-        "unknown", // 3141
-        "unknown", // 3142
-        "unknown", // 3143
-        "unknown", // 3144
-        "unknown", // 3145
-        "unknown", // 3146
-        "unknown", // 3147
-        "unknown", // 3148
-        "unknown", // 3149
-        "unknown", // 3150
-        "unknown", // 3151
-        "unknown", // 3152
-        "unknown", // 3153
-        "unknown", // 3154
-        "unknown", // 3155
-        "unknown", // 3156
-        "unknown", // 3157
-        "unknown", // 3158
-        "unknown", // 3159
-        "unknown", // 3160
-        "unknown", // 3161
-        "unknown", // 3162
-        "unknown", // 3163
-        "unknown", // 3164
-        "unknown", // 3165
-        "unknown", // 3166
-        "unknown", // 3167
-        "unknown", // 3168
-        "unknown", // 3169
-        "unknown", // 3170
-        "unknown", // 3171
-        "unknown", // 3172
-        "unknown", // 3173
-        "unknown", // 3174
-        "unknown", // 3175
-        "unknown", // 3176
-        "unknown", // 3177
-        "unknown", // 3178
-        "unknown", // 3179
-        "unknown", // 3180
-        "unknown", // 3181
-        "unknown", // 3182
-        "unknown", // 3183
-        "unknown", // 3184
-        "unknown", // 3185
-        "unknown", // 3186
-        "unknown", // 3187
-        "unknown", // 3188
-        "unknown", // 3189
-        "unknown", // 3190
-        "unknown", // 3191
-        "unknown", // 3192
-        "unknown", // 3193
-        "unknown", // 3194
-        "unknown", // 3195
-        "unknown", // 3196
-        "unknown", // 3197
-        "unknown", // 3198
-        "unknown", // 3199
-         "cycleh", // 3200
-         "timeh", // 3201
-         "instreth", // 3202
-         "hpmcounter3h", // 3203
-         "hpmcounter4h", // 3204
-         "hpmcounter5h", // 3205
-         "hpmcounter6h", // 3206
-         "hpmcounter7h", // 3207
-         "hpmcounter8h", // 3208
-         "hpmcounter9h", // 3209
-         "hpmcounter10h", // 3210
-         "hpmcounter11h", // 3211
-         "hpmcounter12h", // 3212
-         "hpmcounter13h", // 3213
-         "hpmcounter14h", // 3214
-         "hpmcounter15h", // 3215
-         "hpmcounter16h", // 3216
-         "hpmcounter17h", // 3217
-         "hpmcounter18h", // 3218
-         "hpmcounter19h", // 3219
-         "hpmcounter20h", // 3220
-         "hpmcounter21h", // 3221
-         "hpmcounter22h", // 3222
-         "hpmcounter23h", // 3223
-         "hpmcounter24h", // 3224
-         "hpmcounter25h", // 3225
-         "hpmcounter26h", // 3226
-         "hpmcounter27h", // 3227
-         "hpmcounter28h", // 3228
-         "hpmcounter29h", // 3229
-         "hpmcounter30h", // 3230
-         "hpmcounter31h", // 3231
-        "unknown", // 3232
-        "unknown", // 3233
-        "unknown", // 3234
-        "unknown", // 3235
-        "unknown", // 3236
-        "unknown", // 3237
-        "unknown", // 3238
-        "unknown", // 3239
-        "unknown", // 3240
-        "unknown", // 3241
-        "unknown", // 3242
-        "unknown", // 3243
-        "unknown", // 3244
-        "unknown", // 3245
-        "unknown", // 3246
-        "unknown", // 3247
-        "unknown", // 3248
-        "unknown", // 3249
-        "unknown", // 3250
-        "unknown", // 3251
-        "unknown", // 3252
-        "unknown", // 3253
-        "unknown", // 3254
-        "unknown", // 3255
-        "unknown", // 3256
-        "unknown", // 3257
-        "unknown", // 3258
-        "unknown", // 3259
-        "unknown", // 3260
-        "unknown", // 3261
-        "unknown", // 3262
-        "unknown", // 3263
-        "unknown", // 3264
-        "unknown", // 3265
-        "unknown", // 3266
-        "unknown", // 3267
-        "unknown", // 3268
-        "unknown", // 3269
-        "unknown", // 3270
-        "unknown", // 3271
-        "unknown", // 3272
-        "unknown", // 3273
-        "unknown", // 3274
-        "unknown", // 3275
-        "unknown", // 3276
-        "unknown", // 3277
-        "unknown", // 3278
-        "unknown", // 3279
-        "unknown", // 3280
-        "unknown", // 3281
-        "unknown", // 3282
-        "unknown", // 3283
-        "unknown", // 3284
-        "unknown", // 3285
-        "unknown", // 3286
-        "unknown", // 3287
-        "unknown", // 3288
-        "unknown", // 3289
-        "unknown", // 3290
-        "unknown", // 3291
-        "unknown", // 3292
-        "unknown", // 3293
-        "unknown", // 3294
-        "unknown", // 3295
-        "unknown", // 3296
-        "unknown", // 3297
-        "unknown", // 3298
-        "unknown", // 3299
-        "unknown", // 3300
-        "unknown", // 3301
-        "unknown", // 3302
-        "unknown", // 3303
-        "unknown", // 3304
-        "unknown", // 3305
-        "unknown", // 3306
-        "unknown", // 3307
-        "unknown", // 3308
-        "unknown", // 3309
-        "unknown", // 3310
-        "unknown", // 3311
-        "unknown", // 3312
-        "unknown", // 3313
-        "unknown", // 3314
-        "unknown", // 3315
-        "unknown", // 3316
-        "unknown", // 3317
-        "unknown", // 3318
-        "unknown", // 3319
-        "unknown", // 3320
-        "unknown", // 3321
-        "unknown", // 3322
-        "unknown", // 3323
-        "unknown", // 3324
-        "unknown", // 3325
-        "unknown", // 3326
-        "unknown", // 3327
-        "unknown", // 3328
-        "unknown", // 3329
-        "unknown", // 3330
-        "unknown", // 3331
-        "unknown", // 3332
-        "unknown", // 3333
-        "unknown", // 3334
-        "unknown", // 3335
-        "unknown", // 3336
-        "unknown", // 3337
-        "unknown", // 3338
-        "unknown", // 3339
-        "unknown", // 3340
-        "unknown", // 3341
-        "unknown", // 3342
-        "unknown", // 3343
-        "unknown", // 3344
-        "unknown", // 3345
-        "unknown", // 3346
-        "unknown", // 3347
-        "unknown", // 3348
-        "unknown", // 3349
-        "unknown", // 3350
-        "unknown", // 3351
-        "unknown", // 3352
-        "unknown", // 3353
-        "unknown", // 3354
-        "unknown", // 3355
-        "unknown", // 3356
-        "unknown", // 3357
-        "unknown", // 3358
-        "unknown", // 3359
-        "unknown", // 3360
-        "unknown", // 3361
-        "unknown", // 3362
-        "unknown", // 3363
-        "unknown", // 3364
-        "unknown", // 3365
-        "unknown", // 3366
-        "unknown", // 3367
-        "unknown", // 3368
-        "unknown", // 3369
-        "unknown", // 3370
-        "unknown", // 3371
-        "unknown", // 3372
-        "unknown", // 3373
-        "unknown", // 3374
-        "unknown", // 3375
-        "unknown", // 3376
-        "unknown", // 3377
-        "unknown", // 3378
-        "unknown", // 3379
-        "unknown", // 3380
-        "unknown", // 3381
-        "unknown", // 3382
-        "unknown", // 3383
-        "unknown", // 3384
-        "unknown", // 3385
-        "unknown", // 3386
-        "unknown", // 3387
-        "unknown", // 3388
-        "unknown", // 3389
-        "unknown", // 3390
-        "unknown", // 3391
-        "unknown", // 3392
-        "unknown", // 3393
-        "unknown", // 3394
-        "unknown", // 3395
-        "unknown", // 3396
-        "unknown", // 3397
-        "unknown", // 3398
-        "unknown", // 3399
-        "unknown", // 3400
-        "unknown", // 3401
-        "unknown", // 3402
-        "unknown", // 3403
-        "unknown", // 3404
-        "unknown", // 3405
-        "unknown", // 3406
-        "unknown", // 3407
-        "unknown", // 3408
-        "unknown", // 3409
-        "unknown", // 3410
-        "unknown", // 3411
-        "unknown", // 3412
-        "unknown", // 3413
-        "unknown", // 3414
-        "unknown", // 3415
-        "unknown", // 3416
-        "unknown", // 3417
-        "unknown", // 3418
-        "unknown", // 3419
-        "unknown", // 3420
-        "unknown", // 3421
-        "unknown", // 3422
-        "unknown", // 3423
-        "unknown", // 3424
-        "unknown", // 3425
-        "unknown", // 3426
-        "unknown", // 3427
-        "unknown", // 3428
-        "unknown", // 3429
-        "unknown", // 3430
-        "unknown", // 3431
-        "unknown", // 3432
-        "unknown", // 3433
-        "unknown", // 3434
-        "unknown", // 3435
-        "unknown", // 3436
-        "unknown", // 3437
-        "unknown", // 3438
-        "unknown", // 3439
-        "unknown", // 3440
-        "unknown", // 3441
-        "unknown", // 3442
-        "unknown", // 3443
-        "unknown", // 3444
-        "unknown", // 3445
-        "unknown", // 3446
-        "unknown", // 3447
-        "unknown", // 3448
-        "unknown", // 3449
-        "unknown", // 3450
-        "unknown", // 3451
-        "unknown", // 3452
-        "unknown", // 3453
-        "unknown", // 3454
-        "unknown", // 3455
-        "unknown", // 3456
-        "unknown", // 3457
-        "unknown", // 3458
-        "unknown", // 3459
-        "unknown", // 3460
-        "unknown", // 3461
-        "unknown", // 3462
-        "unknown", // 3463
-        "unknown", // 3464
-        "unknown", // 3465
-        "unknown", // 3466
-        "unknown", // 3467
-        "unknown", // 3468
-        "unknown", // 3469
-        "unknown", // 3470
-        "unknown", // 3471
-        "unknown", // 3472
-        "unknown", // 3473
-        "unknown", // 3474
-        "unknown", // 3475
-        "unknown", // 3476
-        "unknown", // 3477
-        "unknown", // 3478
-        "unknown", // 3479
-        "unknown", // 3480
-        "unknown", // 3481
-        "unknown", // 3482
-        "unknown", // 3483
-        "unknown", // 3484
-        "unknown", // 3485
-        "unknown", // 3486
-        "unknown", // 3487
-         "scountovf", // 3488
-        "unknown", // 3489
-        "unknown", // 3490
-        "unknown", // 3491
-        "unknown", // 3492
-        "unknown", // 3493
-        "unknown", // 3494
-        "unknown", // 3495
-        "unknown", // 3496
-        "unknown", // 3497
-        "unknown", // 3498
-        "unknown", // 3499
-        "unknown", // 3500
-        "unknown", // 3501
-        "unknown", // 3502
-        "unknown", // 3503
-         "stopi", // 3504
-        "unknown", // 3505
-        "unknown", // 3506
-        "unknown", // 3507
-        "unknown", // 3508
-        "unknown", // 3509
-        "unknown", // 3510
-        "unknown", // 3511
-        "unknown", // 3512
-        "unknown", // 3513
-        "unknown", // 3514
-        "unknown", // 3515
-        "unknown", // 3516
-        "unknown", // 3517
-        "unknown", // 3518
-        "unknown", // 3519
-        "unknown", // 3520
-        "unknown", // 3521
-        "unknown", // 3522
-        "unknown", // 3523
-        "unknown", // 3524
-        "unknown", // 3525
-        "unknown", // 3526
-        "unknown", // 3527
-        "unknown", // 3528
-        "unknown", // 3529
-        "unknown", // 3530
-        "unknown", // 3531
-        "unknown", // 3532
-        "unknown", // 3533
-        "unknown", // 3534
-        "unknown", // 3535
-        "unknown", // 3536
-        "unknown", // 3537
-        "unknown", // 3538
-        "unknown", // 3539
-        "unknown", // 3540
-        "unknown", // 3541
-        "unknown", // 3542
-        "unknown", // 3543
-        "unknown", // 3544
-        "unknown", // 3545
-        "unknown", // 3546
-        "unknown", // 3547
-        "unknown", // 3548
-        "unknown", // 3549
-        "unknown", // 3550
-        "unknown", // 3551
-        "unknown", // 3552
-        "unknown", // 3553
-        "unknown", // 3554
-        "unknown", // 3555
-        "unknown", // 3556
-        "unknown", // 3557
-        "unknown", // 3558
-        "unknown", // 3559
-        "unknown", // 3560
-        "unknown", // 3561
-        "unknown", // 3562
-        "unknown", // 3563
-        "unknown", // 3564
-        "unknown", // 3565
-        "unknown", // 3566
-        "unknown", // 3567
-        "unknown", // 3568
-        "unknown", // 3569
-        "unknown", // 3570
-        "unknown", // 3571
-        "unknown", // 3572
-        "unknown", // 3573
-        "unknown", // 3574
-        "unknown", // 3575
-        "unknown", // 3576
-        "unknown", // 3577
-        "unknown", // 3578
-        "unknown", // 3579
-        "unknown", // 3580
-        "unknown", // 3581
-        "unknown", // 3582
-        "unknown", // 3583
-        "unknown", // 3584
-        "unknown", // 3585
-        "unknown", // 3586
-        "unknown", // 3587
-        "unknown", // 3588
-        "unknown", // 3589
-        "unknown", // 3590
-        "unknown", // 3591
-        "unknown", // 3592
-        "unknown", // 3593
-        "unknown", // 3594
-        "unknown", // 3595
-        "unknown", // 3596
-        "unknown", // 3597
-        "unknown", // 3598
-        "unknown", // 3599
-        "unknown", // 3600
-        "unknown", // 3601
-         "hgeip", // 3602
-        "unknown", // 3603
-        "unknown", // 3604
-        "unknown", // 3605
-        "unknown", // 3606
-        "unknown", // 3607
-        "unknown", // 3608
-        "unknown", // 3609
-        "unknown", // 3610
-        "unknown", // 3611
-        "unknown", // 3612
-        "unknown", // 3613
-        "unknown", // 3614
-        "unknown", // 3615
-        "unknown", // 3616
-        "unknown", // 3617
-        "unknown", // 3618
-        "unknown", // 3619
-        "unknown", // 3620
-        "unknown", // 3621
-        "unknown", // 3622
-        "unknown", // 3623
-        "unknown", // 3624
-        "unknown", // 3625
-        "unknown", // 3626
-        "unknown", // 3627
-        "unknown", // 3628
-        "unknown", // 3629
-        "unknown", // 3630
-        "unknown", // 3631
-        "unknown", // 3632
-        "unknown", // 3633
-        "unknown", // 3634
-        "unknown", // 3635
-        "unknown", // 3636
-        "unknown", // 3637
-        "unknown", // 3638
-        "unknown", // 3639
-        "unknown", // 3640
-        "unknown", // 3641
-        "unknown", // 3642
-        "unknown", // 3643
-        "unknown", // 3644
-        "unknown", // 3645
-        "unknown", // 3646
-        "unknown", // 3647
-        "unknown", // 3648
-        "unknown", // 3649
-        "unknown", // 3650
-        "unknown", // 3651
-        "unknown", // 3652
-        "unknown", // 3653
-        "unknown", // 3654
-        "unknown", // 3655
-        "unknown", // 3656
-        "unknown", // 3657
-        "unknown", // 3658
-        "unknown", // 3659
-        "unknown", // 3660
-        "unknown", // 3661
-        "unknown", // 3662
-        "unknown", // 3663
-        "unknown", // 3664
-        "unknown", // 3665
-        "unknown", // 3666
-        "unknown", // 3667
-        "unknown", // 3668
-        "unknown", // 3669
-        "unknown", // 3670
-        "unknown", // 3671
-        "unknown", // 3672
-        "unknown", // 3673
-        "unknown", // 3674
-        "unknown", // 3675
-        "unknown", // 3676
-        "unknown", // 3677
-        "unknown", // 3678
-        "unknown", // 3679
-        "unknown", // 3680
-        "unknown", // 3681
-        "unknown", // 3682
-        "unknown", // 3683
-        "unknown", // 3684
-        "unknown", // 3685
-        "unknown", // 3686
-        "unknown", // 3687
-        "unknown", // 3688
-        "unknown", // 3689
-        "unknown", // 3690
-        "unknown", // 3691
-        "unknown", // 3692
-        "unknown", // 3693
-        "unknown", // 3694
-        "unknown", // 3695
-        "unknown", // 3696
-        "unknown", // 3697
-        "unknown", // 3698
-        "unknown", // 3699
-        "unknown", // 3700
-        "unknown", // 3701
-        "unknown", // 3702
-        "unknown", // 3703
-        "unknown", // 3704
-        "unknown", // 3705
-        "unknown", // 3706
-        "unknown", // 3707
-        "unknown", // 3708
-        "unknown", // 3709
-        "unknown", // 3710
-        "unknown", // 3711
-        "unknown", // 3712
-        "unknown", // 3713
-        "unknown", // 3714
-        "unknown", // 3715
-        "unknown", // 3716
-        "unknown", // 3717
-        "unknown", // 3718
-        "unknown", // 3719
-        "unknown", // 3720
-        "unknown", // 3721
-        "unknown", // 3722
-        "unknown", // 3723
-        "unknown", // 3724
-        "unknown", // 3725
-        "unknown", // 3726
-        "unknown", // 3727
-        "unknown", // 3728
-        "unknown", // 3729
-        "unknown", // 3730
-        "unknown", // 3731
-        "unknown", // 3732
-        "unknown", // 3733
-        "unknown", // 3734
-        "unknown", // 3735
-        "unknown", // 3736
-        "unknown", // 3737
-        "unknown", // 3738
-        "unknown", // 3739
-        "unknown", // 3740
-        "unknown", // 3741
-        "unknown", // 3742
-        "unknown", // 3743
-        "unknown", // 3744
-        "unknown", // 3745
-        "unknown", // 3746
-        "unknown", // 3747
-        "unknown", // 3748
-        "unknown", // 3749
-        "unknown", // 3750
-        "unknown", // 3751
-        "unknown", // 3752
-        "unknown", // 3753
-        "unknown", // 3754
-        "unknown", // 3755
-        "unknown", // 3756
-        "unknown", // 3757
-        "unknown", // 3758
-        "unknown", // 3759
-         "vstopi", // 3760
-        "unknown", // 3761
-        "unknown", // 3762
-        "unknown", // 3763
-        "unknown", // 3764
-        "unknown", // 3765
-        "unknown", // 3766
-        "unknown", // 3767
-        "unknown", // 3768
-        "unknown", // 3769
-        "unknown", // 3770
-        "unknown", // 3771
-        "unknown", // 3772
-        "unknown", // 3773
-        "unknown", // 3774
-        "unknown", // 3775
-        "unknown", // 3776
-        "unknown", // 3777
-        "unknown", // 3778
-        "unknown", // 3779
-        "unknown", // 3780
-        "unknown", // 3781
-        "unknown", // 3782
-        "unknown", // 3783
-        "unknown", // 3784
-        "unknown", // 3785
-        "unknown", // 3786
-        "unknown", // 3787
-        "unknown", // 3788
-        "unknown", // 3789
-        "unknown", // 3790
-        "unknown", // 3791
-        "unknown", // 3792
-        "unknown", // 3793
-        "unknown", // 3794
-        "unknown", // 3795
-        "unknown", // 3796
-        "unknown", // 3797
-        "unknown", // 3798
-        "unknown", // 3799
-        "unknown", // 3800
-        "unknown", // 3801
-        "unknown", // 3802
-        "unknown", // 3803
-        "unknown", // 3804
-        "unknown", // 3805
-        "unknown", // 3806
-        "unknown", // 3807
-        "unknown", // 3808
-        "unknown", // 3809
-        "unknown", // 3810
-        "unknown", // 3811
-        "unknown", // 3812
-        "unknown", // 3813
-        "unknown", // 3814
-        "unknown", // 3815
-        "unknown", // 3816
-        "unknown", // 3817
-        "unknown", // 3818
-        "unknown", // 3819
-        "unknown", // 3820
-        "unknown", // 3821
-        "unknown", // 3822
-        "unknown", // 3823
-        "unknown", // 3824
-        "unknown", // 3825
-        "unknown", // 3826
-        "unknown", // 3827
-        "unknown", // 3828
-        "unknown", // 3829
-        "unknown", // 3830
-        "unknown", // 3831
-        "unknown", // 3832
-        "unknown", // 3833
-        "unknown", // 3834
-        "unknown", // 3835
-        "unknown", // 3836
-        "unknown", // 3837
-        "unknown", // 3838
-        "unknown", // 3839
-        "unknown", // 3840
-        "unknown", // 3841
-        "unknown", // 3842
-        "unknown", // 3843
-        "unknown", // 3844
-        "unknown", // 3845
-        "unknown", // 3846
-        "unknown", // 3847
-        "unknown", // 3848
-        "unknown", // 3849
-        "unknown", // 3850
-        "unknown", // 3851
-        "unknown", // 3852
-        "unknown", // 3853
-        "unknown", // 3854
-        "unknown", // 3855
-        "unknown", // 3856
-         "mvendorid", // 3857
-         "marchid", // 3858
-         "mimpid", // 3859
-         "mhartid", // 3860
-         "mconfigptr", // 3861
-        "unknown", // 3862
-        "unknown", // 3863
-        "unknown", // 3864
-        "unknown", // 3865
-        "unknown", // 3866
-        "unknown", // 3867
-        "unknown", // 3868
-        "unknown", // 3869
-        "unknown", // 3870
-        "unknown", // 3871
-        "unknown", // 3872
-        "unknown", // 3873
-        "unknown", // 3874
-        "unknown", // 3875
-        "unknown", // 3876
-        "unknown", // 3877
-        "unknown", // 3878
-        "unknown", // 3879
-        "unknown", // 3880
-        "unknown", // 3881
-        "unknown", // 3882
-        "unknown", // 3883
-        "unknown", // 3884
-        "unknown", // 3885
-        "unknown", // 3886
-        "unknown", // 3887
-        "unknown", // 3888
-        "unknown", // 3889
-        "unknown", // 3890
-        "unknown", // 3891
-        "unknown", // 3892
-        "unknown", // 3893
-        "unknown", // 3894
-        "unknown", // 3895
-        "unknown", // 3896
-        "unknown", // 3897
-        "unknown", // 3898
-        "unknown", // 3899
-        "unknown", // 3900
-        "unknown", // 3901
-        "unknown", // 3902
-        "unknown", // 3903
-        "unknown", // 3904
-        "unknown", // 3905
-        "unknown", // 3906
-        "unknown", // 3907
-        "unknown", // 3908
-        "unknown", // 3909
-        "unknown", // 3910
-        "unknown", // 3911
-        "unknown", // 3912
-        "unknown", // 3913
-        "unknown", // 3914
-        "unknown", // 3915
-        "unknown", // 3916
-        "unknown", // 3917
-        "unknown", // 3918
-        "unknown", // 3919
-        "unknown", // 3920
-        "unknown", // 3921
-        "unknown", // 3922
-        "unknown", // 3923
-        "unknown", // 3924
-        "unknown", // 3925
-        "unknown", // 3926
-        "unknown", // 3927
-        "unknown", // 3928
-        "unknown", // 3929
-        "unknown", // 3930
-        "unknown", // 3931
-        "unknown", // 3932
-        "unknown", // 3933
-        "unknown", // 3934
-        "unknown", // 3935
-        "unknown", // 3936
-        "unknown", // 3937
-        "unknown", // 3938
-        "unknown", // 3939
-        "unknown", // 3940
-        "unknown", // 3941
-        "unknown", // 3942
-        "unknown", // 3943
-        "unknown", // 3944
-        "unknown", // 3945
-        "unknown", // 3946
-        "unknown", // 3947
-        "unknown", // 3948
-        "unknown", // 3949
-        "unknown", // 3950
-        "unknown", // 3951
-        "unknown", // 3952
-        "unknown", // 3953
-        "unknown", // 3954
-        "unknown", // 3955
-        "unknown", // 3956
-        "unknown", // 3957
-        "unknown", // 3958
-        "unknown", // 3959
-        "unknown", // 3960
-        "unknown", // 3961
-        "unknown", // 3962
-        "unknown", // 3963
-        "unknown", // 3964
-        "unknown", // 3965
-        "unknown", // 3966
-        "unknown", // 3967
-        "unknown", // 3968
-        "unknown", // 3969
-        "unknown", // 3970
-        "unknown", // 3971
-        "unknown", // 3972
-        "unknown", // 3973
-        "unknown", // 3974
-        "unknown", // 3975
-        "unknown", // 3976
-        "unknown", // 3977
-        "unknown", // 3978
-        "unknown", // 3979
-        "unknown", // 3980
-        "unknown", // 3981
-        "unknown", // 3982
-        "unknown", // 3983
-        "unknown", // 3984
-        "unknown", // 3985
-        "unknown", // 3986
-        "unknown", // 3987
-        "unknown", // 3988
-        "unknown", // 3989
-        "unknown", // 3990
-        "unknown", // 3991
-        "unknown", // 3992
-        "unknown", // 3993
-        "unknown", // 3994
-        "unknown", // 3995
-        "unknown", // 3996
-        "unknown", // 3997
-        "unknown", // 3998
-        "unknown", // 3999
-        "unknown", // 4000
-        "unknown", // 4001
-        "unknown", // 4002
-        "unknown", // 4003
-        "unknown", // 4004
-        "unknown", // 4005
-        "unknown", // 4006
-        "unknown", // 4007
-        "unknown", // 4008
-        "unknown", // 4009
-        "unknown", // 4010
-        "unknown", // 4011
-        "unknown", // 4012
-        "unknown", // 4013
-        "unknown", // 4014
-        "unknown", // 4015
-         "mtopi", // 4016
-        "unknown", // 4017
-        "unknown", // 4018
-        "unknown", // 4019
-        "unknown", // 4020
-        "unknown", // 4021
-        "unknown", // 4022
-        "unknown", // 4023
-        "unknown", // 4024
-        "unknown", // 4025
-        "unknown", // 4026
-        "unknown", // 4027
-        "unknown", // 4028
-        "unknown", // 4029
-        "unknown", // 4030
-        "unknown", // 4031
-        "unknown", // 4032
-        "unknown", // 4033
-        "unknown", // 4034
-        "unknown", // 4035
-        "unknown", // 4036
-        "unknown", // 4037
-        "unknown", // 4038
-        "unknown", // 4039
-        "unknown", // 4040
-        "unknown", // 4041
-        "unknown", // 4042
-        "unknown", // 4043
-        "unknown", // 4044
-        "unknown", // 4045
-        "unknown", // 4046
-        "unknown", // 4047
-        "unknown", // 4048
-        "unknown", // 4049
-        "unknown", // 4050
-        "unknown", // 4051
-        "unknown", // 4052
-        "unknown", // 4053
-        "unknown", // 4054
-        "unknown", // 4055
-        "unknown", // 4056
-        "unknown", // 4057
-        "unknown", // 4058
-        "unknown", // 4059
-        "unknown", // 4060
-        "unknown", // 4061
-        "unknown", // 4062
-        "unknown", // 4063
-        "unknown", // 4064
-        "unknown", // 4065
-        "unknown", // 4066
-        "unknown", // 4067
-        "unknown", // 4068
-        "unknown", // 4069
-        "unknown", // 4070
-        "unknown", // 4071
-        "unknown", // 4072
-        "unknown", // 4073
-        "unknown", // 4074
-        "unknown", // 4075
-        "unknown", // 4076
-        "unknown", // 4077
-        "unknown", // 4078
-        "unknown", // 4079
-        "unknown", // 4080
-        "unknown", // 4081
-        "unknown", // 4082
-        "unknown", // 4083
-        "unknown", // 4084
-        "unknown", // 4085
-        "unknown", // 4086
-        "unknown", // 4087
-        "unknown", // 4088
-        "unknown", // 4089
-        "unknown", // 4090
-        "unknown", // 4091
-        "unknown", // 4092
-        "unknown", // 4093
-        "unknown", // 4094
-        "unknown", // 4095
+    "unknown",        // 0
+    "fflags",         // 1
+    "frm",            // 2
+    "fcsr",           // 3
+    "unknown",        // 4
+    "unknown",        // 5
+    "unknown",        // 6
+    "utvt",           // 7
+    "vstart",         // 8
+    "vxsat",          // 9
+    "vxrm",           // 10
+    "unknown",        // 11
+    "unknown",        // 12
+    "unknown",        // 13
+    "unknown",        // 14
+    "vcsr",           // 15
+    "unknown",        // 16
+    "ssp",            // 17
+    "unknown",        // 18
+    "unknown",        // 19
+    "unknown",        // 20
+    "seed",           // 21
+    "unknown",        // 22
+    "jvt",            // 23
+    "unknown",        // 24
+    "unknown",        // 25
+    "unknown",        // 26
+    "unknown",        // 27
+    "unknown",        // 28
+    "unknown",        // 29
+    "unknown",        // 30
+    "unknown",        // 31
+    "unknown",        // 32
+    "unknown",        // 33
+    "unknown",        // 34
+    "unknown",        // 35
+    "unknown",        // 36
+    "unknown",        // 37
+    "unknown",        // 38
+    "unknown",        // 39
+    "unknown",        // 40
+    "unknown",        // 41
+    "unknown",        // 42
+    "unknown",        // 43
+    "unknown",        // 44
+    "unknown",        // 45
+    "unknown",        // 46
+    "unknown",        // 47
+    "unknown",        // 48
+    "unknown",        // 49
+    "unknown",        // 50
+    "unknown",        // 51
+    "unknown",        // 52
+    "unknown",        // 53
+    "unknown",        // 54
+    "unknown",        // 55
+    "unknown",        // 56
+    "unknown",        // 57
+    "unknown",        // 58
+    "unknown",        // 59
+    "unknown",        // 60
+    "unknown",        // 61
+    "unknown",        // 62
+    "unknown",        // 63
+    "unknown",        // 64
+    "unknown",        // 65
+    "unknown",        // 66
+    "unknown",        // 67
+    "unknown",        // 68
+    "unxti",          // 69
+    "uintstatus",     // 70
+    "unknown",        // 71
+    "uscratchcsw",    // 72
+    "uscratchcswl",   // 73
+    "unknown",        // 74
+    "unknown",        // 75
+    "unknown",        // 76
+    "unknown",        // 77
+    "unknown",        // 78
+    "unknown",        // 79
+    "unknown",        // 80
+    "unknown",        // 81
+    "unknown",        // 82
+    "unknown",        // 83
+    "unknown",        // 84
+    "unknown",        // 85
+    "unknown",        // 86
+    "unknown",        // 87
+    "unknown",        // 88
+    "unknown",        // 89
+    "unknown",        // 90
+    "unknown",        // 91
+    "unknown",        // 92
+    "unknown",        // 93
+    "unknown",        // 94
+    "unknown",        // 95
+    "unknown",        // 96
+    "unknown",        // 97
+    "unknown",        // 98
+    "unknown",        // 99
+    "unknown",        // 100
+    "unknown",        // 101
+    "unknown",        // 102
+    "unknown",        // 103
+    "unknown",        // 104
+    "unknown",        // 105
+    "unknown",        // 106
+    "unknown",        // 107
+    "unknown",        // 108
+    "unknown",        // 109
+    "unknown",        // 110
+    "unknown",        // 111
+    "unknown",        // 112
+    "unknown",        // 113
+    "unknown",        // 114
+    "unknown",        // 115
+    "unknown",        // 116
+    "unknown",        // 117
+    "unknown",        // 118
+    "unknown",        // 119
+    "unknown",        // 120
+    "unknown",        // 121
+    "unknown",        // 122
+    "unknown",        // 123
+    "unknown",        // 124
+    "unknown",        // 125
+    "unknown",        // 126
+    "unknown",        // 127
+    "unknown",        // 128
+    "unknown",        // 129
+    "unknown",        // 130
+    "unknown",        // 131
+    "unknown",        // 132
+    "unknown",        // 133
+    "unknown",        // 134
+    "unknown",        // 135
+    "unknown",        // 136
+    "unknown",        // 137
+    "unknown",        // 138
+    "unknown",        // 139
+    "unknown",        // 140
+    "unknown",        // 141
+    "unknown",        // 142
+    "unknown",        // 143
+    "unknown",        // 144
+    "unknown",        // 145
+    "unknown",        // 146
+    "unknown",        // 147
+    "unknown",        // 148
+    "unknown",        // 149
+    "unknown",        // 150
+    "unknown",        // 151
+    "unknown",        // 152
+    "unknown",        // 153
+    "unknown",        // 154
+    "unknown",        // 155
+    "unknown",        // 156
+    "unknown",        // 157
+    "unknown",        // 158
+    "unknown",        // 159
+    "unknown",        // 160
+    "unknown",        // 161
+    "unknown",        // 162
+    "unknown",        // 163
+    "unknown",        // 164
+    "unknown",        // 165
+    "unknown",        // 166
+    "unknown",        // 167
+    "unknown",        // 168
+    "unknown",        // 169
+    "unknown",        // 170
+    "unknown",        // 171
+    "unknown",        // 172
+    "unknown",        // 173
+    "unknown",        // 174
+    "unknown",        // 175
+    "unknown",        // 176
+    "unknown",        // 177
+    "unknown",        // 178
+    "unknown",        // 179
+    "unknown",        // 180
+    "unknown",        // 181
+    "unknown",        // 182
+    "unknown",        // 183
+    "unknown",        // 184
+    "unknown",        // 185
+    "unknown",        // 186
+    "unknown",        // 187
+    "unknown",        // 188
+    "unknown",        // 189
+    "unknown",        // 190
+    "unknown",        // 191
+    "unknown",        // 192
+    "unknown",        // 193
+    "unknown",        // 194
+    "unknown",        // 195
+    "unknown",        // 196
+    "unknown",        // 197
+    "unknown",        // 198
+    "unknown",        // 199
+    "unknown",        // 200
+    "unknown",        // 201
+    "unknown",        // 202
+    "unknown",        // 203
+    "unknown",        // 204
+    "unknown",        // 205
+    "unknown",        // 206
+    "unknown",        // 207
+    "unknown",        // 208
+    "unknown",        // 209
+    "unknown",        // 210
+    "unknown",        // 211
+    "unknown",        // 212
+    "unknown",        // 213
+    "unknown",        // 214
+    "unknown",        // 215
+    "unknown",        // 216
+    "unknown",        // 217
+    "unknown",        // 218
+    "unknown",        // 219
+    "unknown",        // 220
+    "unknown",        // 221
+    "unknown",        // 222
+    "unknown",        // 223
+    "unknown",        // 224
+    "unknown",        // 225
+    "unknown",        // 226
+    "unknown",        // 227
+    "unknown",        // 228
+    "unknown",        // 229
+    "unknown",        // 230
+    "unknown",        // 231
+    "unknown",        // 232
+    "unknown",        // 233
+    "unknown",        // 234
+    "unknown",        // 235
+    "unknown",        // 236
+    "unknown",        // 237
+    "unknown",        // 238
+    "unknown",        // 239
+    "unknown",        // 240
+    "unknown",        // 241
+    "unknown",        // 242
+    "unknown",        // 243
+    "unknown",        // 244
+    "unknown",        // 245
+    "unknown",        // 246
+    "unknown",        // 247
+    "unknown",        // 248
+    "unknown",        // 249
+    "unknown",        // 250
+    "unknown",        // 251
+    "unknown",        // 252
+    "unknown",        // 253
+    "unknown",        // 254
+    "unknown",        // 255
+    "sstatus",        // 256
+    "unknown",        // 257
+    "sedeleg",        // 258
+    "sideleg",        // 259
+    "sie",            // 260
+    "stvec",          // 261
+    "scounteren",     // 262
+    "stvt",           // 263
+    "unknown",        // 264
+    "unknown",        // 265
+    "senvcfg",        // 266
+    "unknown",        // 267
+    "sstateen0",      // 268
+    "sstateen1",      // 269
+    "sstateen2",      // 270
+    "sstateen3",      // 271
+    "unknown",        // 272
+    "unknown",        // 273
+    "unknown",        // 274
+    "unknown",        // 275
+    "sieh",           // 276
+    "unknown",        // 277
+    "unknown",        // 278
+    "unknown",        // 279
+    "unknown",        // 280
+    "unknown",        // 281
+    "unknown",        // 282
+    "unknown",        // 283
+    "unknown",        // 284
+    "unknown",        // 285
+    "unknown",        // 286
+    "unknown",        // 287
+    "scountinhibit",  // 288
+    "unknown",        // 289
+    "unknown",        // 290
+    "unknown",        // 291
+    "unknown",        // 292
+    "unknown",        // 293
+    "unknown",        // 294
+    "unknown",        // 295
+    "unknown",        // 296
+    "unknown",        // 297
+    "unknown",        // 298
+    "unknown",        // 299
+    "unknown",        // 300
+    "unknown",        // 301
+    "unknown",        // 302
+    "unknown",        // 303
+    "unknown",        // 304
+    "unknown",        // 305
+    "unknown",        // 306
+    "unknown",        // 307
+    "unknown",        // 308
+    "unknown",        // 309
+    "unknown",        // 310
+    "unknown",        // 311
+    "unknown",        // 312
+    "unknown",        // 313
+    "unknown",        // 314
+    "unknown",        // 315
+    "unknown",        // 316
+    "unknown",        // 317
+    "unknown",        // 318
+    "unknown",        // 319
+    "sscratch",       // 320
+    "sepc",           // 321
+    "scause",         // 322
+    "stval",          // 323
+    "sip",            // 324
+    "snxti",          // 325
+    "sintstatus",     // 326
+    "unknown",        // 327
+    "sscratchcsw",    // 328
+    "sscratchcswl",   // 329
+    "unknown",        // 330
+    "unknown",        // 331
+    "unknown",        // 332
+    "stimecmp",       // 333
+    "sctrctl",        // 334
+    "sctrstatus",     // 335
+    "siselect",       // 336
+    "sireg",          // 337
+    "sireg2",         // 338
+    "sireg3",         // 339
+    "siph",           // 340
+    "sireg4",         // 341
+    "sireg5",         // 342
+    "sireg6",         // 343
+    "unknown",        // 344
+    "unknown",        // 345
+    "unknown",        // 346
+    "unknown",        // 347
+    "stopei",         // 348
+    "stimecmph",      // 349
+    "unknown",        // 350
+    "sctrdepth",      // 351
+    "unknown",        // 352
+    "unknown",        // 353
+    "unknown",        // 354
+    "unknown",        // 355
+    "unknown",        // 356
+    "unknown",        // 357
+    "unknown",        // 358
+    "unknown",        // 359
+    "unknown",        // 360
+    "unknown",        // 361
+    "unknown",        // 362
+    "unknown",        // 363
+    "unknown",        // 364
+    "unknown",        // 365
+    "unknown",        // 366
+    "unknown",        // 367
+    "unknown",        // 368
+    "unknown",        // 369
+    "unknown",        // 370
+    "unknown",        // 371
+    "unknown",        // 372
+    "unknown",        // 373
+    "unknown",        // 374
+    "unknown",        // 375
+    "unknown",        // 376
+    "unknown",        // 377
+    "unknown",        // 378
+    "unknown",        // 379
+    "unknown",        // 380
+    "unknown",        // 381
+    "unknown",        // 382
+    "unknown",        // 383
+    "satp",           // 384
+    "srmcfg",         // 385
+    "unknown",        // 386
+    "unknown",        // 387
+    "unknown",        // 388
+    "unknown",        // 389
+    "unknown",        // 390
+    "unknown",        // 391
+    "unknown",        // 392
+    "unknown",        // 393
+    "unknown",        // 394
+    "unknown",        // 395
+    "unknown",        // 396
+    "unknown",        // 397
+    "unknown",        // 398
+    "unknown",        // 399
+    "unknown",        // 400
+    "unknown",        // 401
+    "unknown",        // 402
+    "unknown",        // 403
+    "unknown",        // 404
+    "unknown",        // 405
+    "unknown",        // 406
+    "unknown",        // 407
+    "unknown",        // 408
+    "unknown",        // 409
+    "unknown",        // 410
+    "unknown",        // 411
+    "unknown",        // 412
+    "unknown",        // 413
+    "unknown",        // 414
+    "unknown",        // 415
+    "unknown",        // 416
+    "unknown",        // 417
+    "unknown",        // 418
+    "unknown",        // 419
+    "unknown",        // 420
+    "unknown",        // 421
+    "unknown",        // 422
+    "unknown",        // 423
+    "unknown",        // 424
+    "unknown",        // 425
+    "unknown",        // 426
+    "unknown",        // 427
+    "unknown",        // 428
+    "unknown",        // 429
+    "unknown",        // 430
+    "unknown",        // 431
+    "unknown",        // 432
+    "unknown",        // 433
+    "unknown",        // 434
+    "unknown",        // 435
+    "unknown",        // 436
+    "unknown",        // 437
+    "unknown",        // 438
+    "unknown",        // 439
+    "unknown",        // 440
+    "unknown",        // 441
+    "unknown",        // 442
+    "unknown",        // 443
+    "unknown",        // 444
+    "unknown",        // 445
+    "unknown",        // 446
+    "unknown",        // 447
+    "unknown",        // 448
+    "unknown",        // 449
+    "unknown",        // 450
+    "unknown",        // 451
+    "unknown",        // 452
+    "unknown",        // 453
+    "unknown",        // 454
+    "unknown",        // 455
+    "unknown",        // 456
+    "unknown",        // 457
+    "unknown",        // 458
+    "unknown",        // 459
+    "unknown",        // 460
+    "unknown",        // 461
+    "unknown",        // 462
+    "unknown",        // 463
+    "unknown",        // 464
+    "unknown",        // 465
+    "unknown",        // 466
+    "unknown",        // 467
+    "unknown",        // 468
+    "unknown",        // 469
+    "unknown",        // 470
+    "unknown",        // 471
+    "unknown",        // 472
+    "unknown",        // 473
+    "unknown",        // 474
+    "unknown",        // 475
+    "unknown",        // 476
+    "unknown",        // 477
+    "unknown",        // 478
+    "unknown",        // 479
+    "unknown",        // 480
+    "unknown",        // 481
+    "unknown",        // 482
+    "unknown",        // 483
+    "unknown",        // 484
+    "unknown",        // 485
+    "unknown",        // 486
+    "unknown",        // 487
+    "unknown",        // 488
+    "unknown",        // 489
+    "unknown",        // 490
+    "unknown",        // 491
+    "unknown",        // 492
+    "unknown",        // 493
+    "unknown",        // 494
+    "unknown",        // 495
+    "unknown",        // 496
+    "unknown",        // 497
+    "unknown",        // 498
+    "unknown",        // 499
+    "unknown",        // 500
+    "unknown",        // 501
+    "unknown",        // 502
+    "unknown",        // 503
+    "unknown",        // 504
+    "unknown",        // 505
+    "unknown",        // 506
+    "unknown",        // 507
+    "unknown",        // 508
+    "unknown",        // 509
+    "unknown",        // 510
+    "unknown",        // 511
+    "vsstatus",       // 512
+    "unknown",        // 513
+    "unknown",        // 514
+    "unknown",        // 515
+    "vsie",           // 516
+    "vstvec",         // 517
+    "unknown",        // 518
+    "unknown",        // 519
+    "unknown",        // 520
+    "unknown",        // 521
+    "unknown",        // 522
+    "unknown",        // 523
+    "unknown",        // 524
+    "unknown",        // 525
+    "unknown",        // 526
+    "unknown",        // 527
+    "unknown",        // 528
+    "unknown",        // 529
+    "unknown",        // 530
+    "unknown",        // 531
+    "vsieh",          // 532
+    "unknown",        // 533
+    "unknown",        // 534
+    "unknown",        // 535
+    "unknown",        // 536
+    "unknown",        // 537
+    "unknown",        // 538
+    "unknown",        // 539
+    "unknown",        // 540
+    "unknown",        // 541
+    "unknown",        // 542
+    "unknown",        // 543
+    "unknown",        // 544
+    "unknown",        // 545
+    "unknown",        // 546
+    "unknown",        // 547
+    "unknown",        // 548
+    "unknown",        // 549
+    "unknown",        // 550
+    "unknown",        // 551
+    "unknown",        // 552
+    "unknown",        // 553
+    "unknown",        // 554
+    "unknown",        // 555
+    "unknown",        // 556
+    "unknown",        // 557
+    "unknown",        // 558
+    "unknown",        // 559
+    "unknown",        // 560
+    "unknown",        // 561
+    "unknown",        // 562
+    "unknown",        // 563
+    "unknown",        // 564
+    "unknown",        // 565
+    "unknown",        // 566
+    "unknown",        // 567
+    "unknown",        // 568
+    "unknown",        // 569
+    "unknown",        // 570
+    "unknown",        // 571
+    "unknown",        // 572
+    "unknown",        // 573
+    "unknown",        // 574
+    "unknown",        // 575
+    "vsscratch",      // 576
+    "vsepc",          // 577
+    "vscause",        // 578
+    "vstval",         // 579
+    "vsip",           // 580
+    "unknown",        // 581
+    "unknown",        // 582
+    "unknown",        // 583
+    "unknown",        // 584
+    "unknown",        // 585
+    "unknown",        // 586
+    "unknown",        // 587
+    "unknown",        // 588
+    "vstimecmp",      // 589
+    "vsctrctl",       // 590
+    "unknown",        // 591
+    "vsiselect",      // 592
+    "vsireg",         // 593
+    "vsireg2",        // 594
+    "vsireg3",        // 595
+    "vsiph",          // 596
+    "vsireg4",        // 597
+    "vsireg5",        // 598
+    "vsireg6",        // 599
+    "unknown",        // 600
+    "unknown",        // 601
+    "unknown",        // 602
+    "unknown",        // 603
+    "vstopei",        // 604
+    "vstimecmph",     // 605
+    "unknown",        // 606
+    "unknown",        // 607
+    "unknown",        // 608
+    "unknown",        // 609
+    "unknown",        // 610
+    "unknown",        // 611
+    "unknown",        // 612
+    "unknown",        // 613
+    "unknown",        // 614
+    "unknown",        // 615
+    "unknown",        // 616
+    "unknown",        // 617
+    "unknown",        // 618
+    "unknown",        // 619
+    "unknown",        // 620
+    "unknown",        // 621
+    "unknown",        // 622
+    "unknown",        // 623
+    "unknown",        // 624
+    "unknown",        // 625
+    "unknown",        // 626
+    "unknown",        // 627
+    "unknown",        // 628
+    "unknown",        // 629
+    "unknown",        // 630
+    "unknown",        // 631
+    "unknown",        // 632
+    "unknown",        // 633
+    "unknown",        // 634
+    "unknown",        // 635
+    "unknown",        // 636
+    "unknown",        // 637
+    "unknown",        // 638
+    "unknown",        // 639
+    "vsatp",          // 640
+    "unknown",        // 641
+    "unknown",        // 642
+    "unknown",        // 643
+    "unknown",        // 644
+    "unknown",        // 645
+    "unknown",        // 646
+    "unknown",        // 647
+    "unknown",        // 648
+    "unknown",        // 649
+    "unknown",        // 650
+    "unknown",        // 651
+    "unknown",        // 652
+    "unknown",        // 653
+    "unknown",        // 654
+    "unknown",        // 655
+    "unknown",        // 656
+    "unknown",        // 657
+    "unknown",        // 658
+    "unknown",        // 659
+    "unknown",        // 660
+    "unknown",        // 661
+    "unknown",        // 662
+    "unknown",        // 663
+    "unknown",        // 664
+    "unknown",        // 665
+    "unknown",        // 666
+    "unknown",        // 667
+    "unknown",        // 668
+    "unknown",        // 669
+    "unknown",        // 670
+    "unknown",        // 671
+    "unknown",        // 672
+    "unknown",        // 673
+    "unknown",        // 674
+    "unknown",        // 675
+    "unknown",        // 676
+    "unknown",        // 677
+    "unknown",        // 678
+    "unknown",        // 679
+    "unknown",        // 680
+    "unknown",        // 681
+    "unknown",        // 682
+    "unknown",        // 683
+    "unknown",        // 684
+    "unknown",        // 685
+    "unknown",        // 686
+    "unknown",        // 687
+    "unknown",        // 688
+    "unknown",        // 689
+    "unknown",        // 690
+    "unknown",        // 691
+    "unknown",        // 692
+    "unknown",        // 693
+    "unknown",        // 694
+    "unknown",        // 695
+    "unknown",        // 696
+    "unknown",        // 697
+    "unknown",        // 698
+    "unknown",        // 699
+    "unknown",        // 700
+    "unknown",        // 701
+    "unknown",        // 702
+    "unknown",        // 703
+    "unknown",        // 704
+    "unknown",        // 705
+    "unknown",        // 706
+    "unknown",        // 707
+    "unknown",        // 708
+    "unknown",        // 709
+    "unknown",        // 710
+    "unknown",        // 711
+    "unknown",        // 712
+    "unknown",        // 713
+    "unknown",        // 714
+    "unknown",        // 715
+    "unknown",        // 716
+    "unknown",        // 717
+    "unknown",        // 718
+    "unknown",        // 719
+    "unknown",        // 720
+    "unknown",        // 721
+    "unknown",        // 722
+    "unknown",        // 723
+    "unknown",        // 724
+    "unknown",        // 725
+    "unknown",        // 726
+    "unknown",        // 727
+    "unknown",        // 728
+    "unknown",        // 729
+    "unknown",        // 730
+    "unknown",        // 731
+    "unknown",        // 732
+    "unknown",        // 733
+    "unknown",        // 734
+    "unknown",        // 735
+    "unknown",        // 736
+    "unknown",        // 737
+    "unknown",        // 738
+    "unknown",        // 739
+    "unknown",        // 740
+    "unknown",        // 741
+    "unknown",        // 742
+    "unknown",        // 743
+    "unknown",        // 744
+    "unknown",        // 745
+    "unknown",        // 746
+    "unknown",        // 747
+    "unknown",        // 748
+    "unknown",        // 749
+    "unknown",        // 750
+    "unknown",        // 751
+    "unknown",        // 752
+    "unknown",        // 753
+    "unknown",        // 754
+    "unknown",        // 755
+    "unknown",        // 756
+    "unknown",        // 757
+    "unknown",        // 758
+    "unknown",        // 759
+    "unknown",        // 760
+    "unknown",        // 761
+    "unknown",        // 762
+    "unknown",        // 763
+    "unknown",        // 764
+    "unknown",        // 765
+    "unknown",        // 766
+    "unknown",        // 767
+    "mstatus",        // 768
+    "misa",           // 769
+    "medeleg",        // 770
+    "mideleg",        // 771
+    "mie",            // 772
+    "mtvec",          // 773
+    "mcounteren",     // 774
+    "mtvt",           // 775
+    "mvien",          // 776
+    "mvip",           // 777
+    "menvcfg",        // 778
+    "unknown",        // 779
+    "mstateen0",      // 780
+    "mstateen1",      // 781
+    "mstateen2",      // 782
+    "mstateen3",      // 783
+    "mstatush",       // 784
+    "unknown",        // 785
+    "unknown",        // 786
+    "midelegh",       // 787
+    "mieh",           // 788
+    "unknown",        // 789
+    "unknown",        // 790
+    "unknown",        // 791
+    "mvienh",         // 792
+    "mviph",          // 793
+    "menvcfgh",       // 794
+    "unknown",        // 795
+    "mstateen0h",     // 796
+    "mstateen1h",     // 797
+    "mstateen2h",     // 798
+    "mstateen3h",     // 799
+    "mcountinhibit",  // 800
+    "mcyclecfg",      // 801
+    "minstretcfg",    // 802
+    "mhpmevent3",     // 803
+    "mhpmevent4",     // 804
+    "mhpmevent5",     // 805
+    "mhpmevent6",     // 806
+    "mhpmevent7",     // 807
+    "mhpmevent8",     // 808
+    "mhpmevent9",     // 809
+    "mhpmevent10",    // 810
+    "mhpmevent11",    // 811
+    "mhpmevent12",    // 812
+    "mhpmevent13",    // 813
+    "mhpmevent14",    // 814
+    "mhpmevent15",    // 815
+    "mhpmevent16",    // 816
+    "mhpmevent17",    // 817
+    "mhpmevent18",    // 818
+    "mhpmevent19",    // 819
+    "mhpmevent20",    // 820
+    "mhpmevent21",    // 821
+    "mhpmevent22",    // 822
+    "mhpmevent23",    // 823
+    "mhpmevent24",    // 824
+    "mhpmevent25",    // 825
+    "mhpmevent26",    // 826
+    "mhpmevent27",    // 827
+    "mhpmevent28",    // 828
+    "mhpmevent29",    // 829
+    "mhpmevent30",    // 830
+    "mhpmevent31",    // 831
+    "mscratch",       // 832
+    "mepc",           // 833
+    "mcause",         // 834
+    "mtval",          // 835
+    "mip",            // 836
+    "mnxti",          // 837
+    "mintstatus",     // 838
+    "unknown",        // 839
+    "mscratchcsw",    // 840
+    "mscratchcswl",   // 841
+    "mtinst",         // 842
+    "mtval2",         // 843
+    "unknown",        // 844
+    "unknown",        // 845
+    "mctrctl",        // 846
+    "unknown",        // 847
+    "miselect",       // 848
+    "mireg",          // 849
+    "mireg2",         // 850
+    "mireg3",         // 851
+    "miph",           // 852
+    "mireg4",         // 853
+    "mireg5",         // 854
+    "mireg6",         // 855
+    "unknown",        // 856
+    "unknown",        // 857
+    "unknown",        // 858
+    "unknown",        // 859
+    "mtopei",         // 860
+    "unknown",        // 861
+    "unknown",        // 862
+    "unknown",        // 863
+    "unknown",        // 864
+    "unknown",        // 865
+    "unknown",        // 866
+    "unknown",        // 867
+    "unknown",        // 868
+    "unknown",        // 869
+    "unknown",        // 870
+    "unknown",        // 871
+    "unknown",        // 872
+    "unknown",        // 873
+    "unknown",        // 874
+    "unknown",        // 875
+    "unknown",        // 876
+    "unknown",        // 877
+    "unknown",        // 878
+    "unknown",        // 879
+    "unknown",        // 880
+    "unknown",        // 881
+    "unknown",        // 882
+    "unknown",        // 883
+    "unknown",        // 884
+    "unknown",        // 885
+    "unknown",        // 886
+    "unknown",        // 887
+    "unknown",        // 888
+    "unknown",        // 889
+    "unknown",        // 890
+    "unknown",        // 891
+    "unknown",        // 892
+    "unknown",        // 893
+    "unknown",        // 894
+    "unknown",        // 895
+    "unknown",        // 896
+    "unknown",        // 897
+    "unknown",        // 898
+    "unknown",        // 899
+    "unknown",        // 900
+    "unknown",        // 901
+    "unknown",        // 902
+    "unknown",        // 903
+    "unknown",        // 904
+    "unknown",        // 905
+    "unknown",        // 906
+    "unknown",        // 907
+    "unknown",        // 908
+    "unknown",        // 909
+    "unknown",        // 910
+    "unknown",        // 911
+    "unknown",        // 912
+    "unknown",        // 913
+    "unknown",        // 914
+    "unknown",        // 915
+    "unknown",        // 916
+    "unknown",        // 917
+    "unknown",        // 918
+    "unknown",        // 919
+    "unknown",        // 920
+    "unknown",        // 921
+    "unknown",        // 922
+    "unknown",        // 923
+    "unknown",        // 924
+    "unknown",        // 925
+    "unknown",        // 926
+    "unknown",        // 927
+    "pmpcfg0",        // 928
+    "pmpcfg1",        // 929
+    "pmpcfg2",        // 930
+    "pmpcfg3",        // 931
+    "pmpcfg4",        // 932
+    "pmpcfg5",        // 933
+    "pmpcfg6",        // 934
+    "pmpcfg7",        // 935
+    "pmpcfg8",        // 936
+    "pmpcfg9",        // 937
+    "pmpcfg10",       // 938
+    "pmpcfg11",       // 939
+    "pmpcfg12",       // 940
+    "pmpcfg13",       // 941
+    "pmpcfg14",       // 942
+    "pmpcfg15",       // 943
+    "pmpaddr0",       // 944
+    "pmpaddr1",       // 945
+    "pmpaddr2",       // 946
+    "pmpaddr3",       // 947
+    "pmpaddr4",       // 948
+    "pmpaddr5",       // 949
+    "pmpaddr6",       // 950
+    "pmpaddr7",       // 951
+    "pmpaddr8",       // 952
+    "pmpaddr9",       // 953
+    "pmpaddr10",      // 954
+    "pmpaddr11",      // 955
+    "pmpaddr12",      // 956
+    "pmpaddr13",      // 957
+    "pmpaddr14",      // 958
+    "pmpaddr15",      // 959
+    "pmpaddr16",      // 960
+    "pmpaddr17",      // 961
+    "pmpaddr18",      // 962
+    "pmpaddr19",      // 963
+    "pmpaddr20",      // 964
+    "pmpaddr21",      // 965
+    "pmpaddr22",      // 966
+    "pmpaddr23",      // 967
+    "pmpaddr24",      // 968
+    "pmpaddr25",      // 969
+    "pmpaddr26",      // 970
+    "pmpaddr27",      // 971
+    "pmpaddr28",      // 972
+    "pmpaddr29",      // 973
+    "pmpaddr30",      // 974
+    "pmpaddr31",      // 975
+    "pmpaddr32",      // 976
+    "pmpaddr33",      // 977
+    "pmpaddr34",      // 978
+    "pmpaddr35",      // 979
+    "pmpaddr36",      // 980
+    "pmpaddr37",      // 981
+    "pmpaddr38",      // 982
+    "pmpaddr39",      // 983
+    "pmpaddr40",      // 984
+    "pmpaddr41",      // 985
+    "pmpaddr42",      // 986
+    "pmpaddr43",      // 987
+    "pmpaddr44",      // 988
+    "pmpaddr45",      // 989
+    "pmpaddr46",      // 990
+    "pmpaddr47",      // 991
+    "pmpaddr48",      // 992
+    "pmpaddr49",      // 993
+    "pmpaddr50",      // 994
+    "pmpaddr51",      // 995
+    "pmpaddr52",      // 996
+    "pmpaddr53",      // 997
+    "pmpaddr54",      // 998
+    "pmpaddr55",      // 999
+    "pmpaddr56",      // 1000
+    "pmpaddr57",      // 1001
+    "pmpaddr58",      // 1002
+    "pmpaddr59",      // 1003
+    "pmpaddr60",      // 1004
+    "pmpaddr61",      // 1005
+    "pmpaddr62",      // 1006
+    "pmpaddr63",      // 1007
+    "unknown",        // 1008
+    "unknown",        // 1009
+    "unknown",        // 1010
+    "unknown",        // 1011
+    "unknown",        // 1012
+    "unknown",        // 1013
+    "unknown",        // 1014
+    "unknown",        // 1015
+    "unknown",        // 1016
+    "unknown",        // 1017
+    "unknown",        // 1018
+    "unknown",        // 1019
+    "unknown",        // 1020
+    "unknown",        // 1021
+    "unknown",        // 1022
+    "unknown",        // 1023
+    "unknown",        // 1024
+    "unknown",        // 1025
+    "unknown",        // 1026
+    "unknown",        // 1027
+    "unknown",        // 1028
+    "unknown",        // 1029
+    "unknown",        // 1030
+    "unknown",        // 1031
+    "unknown",        // 1032
+    "unknown",        // 1033
+    "unknown",        // 1034
+    "unknown",        // 1035
+    "unknown",        // 1036
+    "unknown",        // 1037
+    "unknown",        // 1038
+    "unknown",        // 1039
+    "unknown",        // 1040
+    "unknown",        // 1041
+    "unknown",        // 1042
+    "unknown",        // 1043
+    "unknown",        // 1044
+    "unknown",        // 1045
+    "unknown",        // 1046
+    "unknown",        // 1047
+    "unknown",        // 1048
+    "unknown",        // 1049
+    "unknown",        // 1050
+    "unknown",        // 1051
+    "unknown",        // 1052
+    "unknown",        // 1053
+    "unknown",        // 1054
+    "unknown",        // 1055
+    "unknown",        // 1056
+    "unknown",        // 1057
+    "unknown",        // 1058
+    "unknown",        // 1059
+    "unknown",        // 1060
+    "unknown",        // 1061
+    "unknown",        // 1062
+    "unknown",        // 1063
+    "unknown",        // 1064
+    "unknown",        // 1065
+    "unknown",        // 1066
+    "unknown",        // 1067
+    "unknown",        // 1068
+    "unknown",        // 1069
+    "unknown",        // 1070
+    "unknown",        // 1071
+    "unknown",        // 1072
+    "unknown",        // 1073
+    "unknown",        // 1074
+    "unknown",        // 1075
+    "unknown",        // 1076
+    "unknown",        // 1077
+    "unknown",        // 1078
+    "unknown",        // 1079
+    "unknown",        // 1080
+    "unknown",        // 1081
+    "unknown",        // 1082
+    "unknown",        // 1083
+    "unknown",        // 1084
+    "unknown",        // 1085
+    "unknown",        // 1086
+    "unknown",        // 1087
+    "unknown",        // 1088
+    "unknown",        // 1089
+    "unknown",        // 1090
+    "unknown",        // 1091
+    "unknown",        // 1092
+    "unknown",        // 1093
+    "unknown",        // 1094
+    "unknown",        // 1095
+    "unknown",        // 1096
+    "unknown",        // 1097
+    "unknown",        // 1098
+    "unknown",        // 1099
+    "unknown",        // 1100
+    "unknown",        // 1101
+    "unknown",        // 1102
+    "unknown",        // 1103
+    "unknown",        // 1104
+    "unknown",        // 1105
+    "unknown",        // 1106
+    "unknown",        // 1107
+    "unknown",        // 1108
+    "unknown",        // 1109
+    "unknown",        // 1110
+    "unknown",        // 1111
+    "unknown",        // 1112
+    "unknown",        // 1113
+    "unknown",        // 1114
+    "unknown",        // 1115
+    "unknown",        // 1116
+    "unknown",        // 1117
+    "unknown",        // 1118
+    "unknown",        // 1119
+    "unknown",        // 1120
+    "unknown",        // 1121
+    "unknown",        // 1122
+    "unknown",        // 1123
+    "unknown",        // 1124
+    "unknown",        // 1125
+    "unknown",        // 1126
+    "unknown",        // 1127
+    "unknown",        // 1128
+    "unknown",        // 1129
+    "unknown",        // 1130
+    "unknown",        // 1131
+    "unknown",        // 1132
+    "unknown",        // 1133
+    "unknown",        // 1134
+    "unknown",        // 1135
+    "unknown",        // 1136
+    "unknown",        // 1137
+    "unknown",        // 1138
+    "unknown",        // 1139
+    "unknown",        // 1140
+    "unknown",        // 1141
+    "unknown",        // 1142
+    "unknown",        // 1143
+    "unknown",        // 1144
+    "unknown",        // 1145
+    "unknown",        // 1146
+    "unknown",        // 1147
+    "unknown",        // 1148
+    "unknown",        // 1149
+    "unknown",        // 1150
+    "unknown",        // 1151
+    "unknown",        // 1152
+    "unknown",        // 1153
+    "unknown",        // 1154
+    "unknown",        // 1155
+    "unknown",        // 1156
+    "unknown",        // 1157
+    "unknown",        // 1158
+    "unknown",        // 1159
+    "unknown",        // 1160
+    "unknown",        // 1161
+    "unknown",        // 1162
+    "unknown",        // 1163
+    "unknown",        // 1164
+    "unknown",        // 1165
+    "unknown",        // 1166
+    "unknown",        // 1167
+    "unknown",        // 1168
+    "unknown",        // 1169
+    "unknown",        // 1170
+    "unknown",        // 1171
+    "unknown",        // 1172
+    "unknown",        // 1173
+    "unknown",        // 1174
+    "unknown",        // 1175
+    "unknown",        // 1176
+    "unknown",        // 1177
+    "unknown",        // 1178
+    "unknown",        // 1179
+    "unknown",        // 1180
+    "unknown",        // 1181
+    "unknown",        // 1182
+    "unknown",        // 1183
+    "unknown",        // 1184
+    "unknown",        // 1185
+    "unknown",        // 1186
+    "unknown",        // 1187
+    "unknown",        // 1188
+    "unknown",        // 1189
+    "unknown",        // 1190
+    "unknown",        // 1191
+    "unknown",        // 1192
+    "unknown",        // 1193
+    "unknown",        // 1194
+    "unknown",        // 1195
+    "unknown",        // 1196
+    "unknown",        // 1197
+    "unknown",        // 1198
+    "unknown",        // 1199
+    "unknown",        // 1200
+    "unknown",        // 1201
+    "unknown",        // 1202
+    "unknown",        // 1203
+    "unknown",        // 1204
+    "unknown",        // 1205
+    "unknown",        // 1206
+    "unknown",        // 1207
+    "unknown",        // 1208
+    "unknown",        // 1209
+    "unknown",        // 1210
+    "unknown",        // 1211
+    "unknown",        // 1212
+    "unknown",        // 1213
+    "unknown",        // 1214
+    "unknown",        // 1215
+    "unknown",        // 1216
+    "unknown",        // 1217
+    "unknown",        // 1218
+    "unknown",        // 1219
+    "unknown",        // 1220
+    "unknown",        // 1221
+    "unknown",        // 1222
+    "unknown",        // 1223
+    "unknown",        // 1224
+    "unknown",        // 1225
+    "unknown",        // 1226
+    "unknown",        // 1227
+    "unknown",        // 1228
+    "unknown",        // 1229
+    "unknown",        // 1230
+    "unknown",        // 1231
+    "unknown",        // 1232
+    "unknown",        // 1233
+    "unknown",        // 1234
+    "unknown",        // 1235
+    "unknown",        // 1236
+    "unknown",        // 1237
+    "unknown",        // 1238
+    "unknown",        // 1239
+    "unknown",        // 1240
+    "unknown",        // 1241
+    "unknown",        // 1242
+    "unknown",        // 1243
+    "unknown",        // 1244
+    "unknown",        // 1245
+    "unknown",        // 1246
+    "unknown",        // 1247
+    "unknown",        // 1248
+    "unknown",        // 1249
+    "unknown",        // 1250
+    "unknown",        // 1251
+    "unknown",        // 1252
+    "unknown",        // 1253
+    "unknown",        // 1254
+    "unknown",        // 1255
+    "unknown",        // 1256
+    "unknown",        // 1257
+    "unknown",        // 1258
+    "unknown",        // 1259
+    "unknown",        // 1260
+    "unknown",        // 1261
+    "unknown",        // 1262
+    "unknown",        // 1263
+    "unknown",        // 1264
+    "unknown",        // 1265
+    "unknown",        // 1266
+    "unknown",        // 1267
+    "unknown",        // 1268
+    "unknown",        // 1269
+    "unknown",        // 1270
+    "unknown",        // 1271
+    "unknown",        // 1272
+    "unknown",        // 1273
+    "unknown",        // 1274
+    "unknown",        // 1275
+    "unknown",        // 1276
+    "unknown",        // 1277
+    "unknown",        // 1278
+    "unknown",        // 1279
+    "unknown",        // 1280
+    "unknown",        // 1281
+    "unknown",        // 1282
+    "unknown",        // 1283
+    "unknown",        // 1284
+    "unknown",        // 1285
+    "unknown",        // 1286
+    "unknown",        // 1287
+    "unknown",        // 1288
+    "unknown",        // 1289
+    "unknown",        // 1290
+    "unknown",        // 1291
+    "unknown",        // 1292
+    "unknown",        // 1293
+    "unknown",        // 1294
+    "unknown",        // 1295
+    "unknown",        // 1296
+    "unknown",        // 1297
+    "unknown",        // 1298
+    "unknown",        // 1299
+    "unknown",        // 1300
+    "unknown",        // 1301
+    "unknown",        // 1302
+    "unknown",        // 1303
+    "unknown",        // 1304
+    "unknown",        // 1305
+    "unknown",        // 1306
+    "unknown",        // 1307
+    "unknown",        // 1308
+    "unknown",        // 1309
+    "unknown",        // 1310
+    "unknown",        // 1311
+    "unknown",        // 1312
+    "unknown",        // 1313
+    "unknown",        // 1314
+    "unknown",        // 1315
+    "unknown",        // 1316
+    "unknown",        // 1317
+    "unknown",        // 1318
+    "unknown",        // 1319
+    "unknown",        // 1320
+    "unknown",        // 1321
+    "unknown",        // 1322
+    "unknown",        // 1323
+    "unknown",        // 1324
+    "unknown",        // 1325
+    "unknown",        // 1326
+    "unknown",        // 1327
+    "unknown",        // 1328
+    "unknown",        // 1329
+    "unknown",        // 1330
+    "unknown",        // 1331
+    "unknown",        // 1332
+    "unknown",        // 1333
+    "unknown",        // 1334
+    "unknown",        // 1335
+    "unknown",        // 1336
+    "unknown",        // 1337
+    "unknown",        // 1338
+    "unknown",        // 1339
+    "unknown",        // 1340
+    "unknown",        // 1341
+    "unknown",        // 1342
+    "unknown",        // 1343
+    "unknown",        // 1344
+    "unknown",        // 1345
+    "unknown",        // 1346
+    "unknown",        // 1347
+    "unknown",        // 1348
+    "unknown",        // 1349
+    "unknown",        // 1350
+    "unknown",        // 1351
+    "unknown",        // 1352
+    "unknown",        // 1353
+    "unknown",        // 1354
+    "unknown",        // 1355
+    "unknown",        // 1356
+    "unknown",        // 1357
+    "unknown",        // 1358
+    "unknown",        // 1359
+    "unknown",        // 1360
+    "unknown",        // 1361
+    "unknown",        // 1362
+    "unknown",        // 1363
+    "unknown",        // 1364
+    "unknown",        // 1365
+    "unknown",        // 1366
+    "unknown",        // 1367
+    "unknown",        // 1368
+    "unknown",        // 1369
+    "unknown",        // 1370
+    "unknown",        // 1371
+    "unknown",        // 1372
+    "unknown",        // 1373
+    "unknown",        // 1374
+    "unknown",        // 1375
+    "unknown",        // 1376
+    "unknown",        // 1377
+    "unknown",        // 1378
+    "unknown",        // 1379
+    "unknown",        // 1380
+    "unknown",        // 1381
+    "unknown",        // 1382
+    "unknown",        // 1383
+    "unknown",        // 1384
+    "unknown",        // 1385
+    "unknown",        // 1386
+    "unknown",        // 1387
+    "unknown",        // 1388
+    "unknown",        // 1389
+    "unknown",        // 1390
+    "unknown",        // 1391
+    "unknown",        // 1392
+    "unknown",        // 1393
+    "unknown",        // 1394
+    "unknown",        // 1395
+    "unknown",        // 1396
+    "unknown",        // 1397
+    "unknown",        // 1398
+    "unknown",        // 1399
+    "unknown",        // 1400
+    "unknown",        // 1401
+    "unknown",        // 1402
+    "unknown",        // 1403
+    "unknown",        // 1404
+    "unknown",        // 1405
+    "unknown",        // 1406
+    "unknown",        // 1407
+    "unknown",        // 1408
+    "unknown",        // 1409
+    "unknown",        // 1410
+    "unknown",        // 1411
+    "unknown",        // 1412
+    "unknown",        // 1413
+    "unknown",        // 1414
+    "unknown",        // 1415
+    "unknown",        // 1416
+    "unknown",        // 1417
+    "unknown",        // 1418
+    "unknown",        // 1419
+    "unknown",        // 1420
+    "unknown",        // 1421
+    "unknown",        // 1422
+    "unknown",        // 1423
+    "unknown",        // 1424
+    "unknown",        // 1425
+    "unknown",        // 1426
+    "unknown",        // 1427
+    "unknown",        // 1428
+    "unknown",        // 1429
+    "unknown",        // 1430
+    "unknown",        // 1431
+    "unknown",        // 1432
+    "unknown",        // 1433
+    "unknown",        // 1434
+    "unknown",        // 1435
+    "unknown",        // 1436
+    "unknown",        // 1437
+    "unknown",        // 1438
+    "unknown",        // 1439
+    "unknown",        // 1440
+    "unknown",        // 1441
+    "unknown",        // 1442
+    "unknown",        // 1443
+    "unknown",        // 1444
+    "unknown",        // 1445
+    "unknown",        // 1446
+    "unknown",        // 1447
+    "scontext",       // 1448
+    "unknown",        // 1449
+    "unknown",        // 1450
+    "unknown",        // 1451
+    "unknown",        // 1452
+    "unknown",        // 1453
+    "unknown",        // 1454
+    "unknown",        // 1455
+    "unknown",        // 1456
+    "unknown",        // 1457
+    "unknown",        // 1458
+    "unknown",        // 1459
+    "unknown",        // 1460
+    "unknown",        // 1461
+    "unknown",        // 1462
+    "unknown",        // 1463
+    "unknown",        // 1464
+    "unknown",        // 1465
+    "unknown",        // 1466
+    "unknown",        // 1467
+    "unknown",        // 1468
+    "unknown",        // 1469
+    "unknown",        // 1470
+    "unknown",        // 1471
+    "unknown",        // 1472
+    "unknown",        // 1473
+    "unknown",        // 1474
+    "unknown",        // 1475
+    "unknown",        // 1476
+    "unknown",        // 1477
+    "unknown",        // 1478
+    "unknown",        // 1479
+    "unknown",        // 1480
+    "unknown",        // 1481
+    "unknown",        // 1482
+    "unknown",        // 1483
+    "unknown",        // 1484
+    "unknown",        // 1485
+    "unknown",        // 1486
+    "unknown",        // 1487
+    "unknown",        // 1488
+    "unknown",        // 1489
+    "unknown",        // 1490
+    "unknown",        // 1491
+    "unknown",        // 1492
+    "unknown",        // 1493
+    "unknown",        // 1494
+    "unknown",        // 1495
+    "unknown",        // 1496
+    "unknown",        // 1497
+    "unknown",        // 1498
+    "unknown",        // 1499
+    "unknown",        // 1500
+    "unknown",        // 1501
+    "unknown",        // 1502
+    "unknown",        // 1503
+    "unknown",        // 1504
+    "unknown",        // 1505
+    "unknown",        // 1506
+    "unknown",        // 1507
+    "unknown",        // 1508
+    "unknown",        // 1509
+    "unknown",        // 1510
+    "unknown",        // 1511
+    "unknown",        // 1512
+    "unknown",        // 1513
+    "unknown",        // 1514
+    "unknown",        // 1515
+    "unknown",        // 1516
+    "unknown",        // 1517
+    "unknown",        // 1518
+    "unknown",        // 1519
+    "unknown",        // 1520
+    "unknown",        // 1521
+    "unknown",        // 1522
+    "unknown",        // 1523
+    "unknown",        // 1524
+    "unknown",        // 1525
+    "unknown",        // 1526
+    "unknown",        // 1527
+    "unknown",        // 1528
+    "unknown",        // 1529
+    "unknown",        // 1530
+    "unknown",        // 1531
+    "unknown",        // 1532
+    "unknown",        // 1533
+    "unknown",        // 1534
+    "unknown",        // 1535
+    "hstatus",        // 1536
+    "unknown",        // 1537
+    "hedeleg",        // 1538
+    "hideleg",        // 1539
+    "hie",            // 1540
+    "htimedelta",     // 1541
+    "hcounteren",     // 1542
+    "hgeie",          // 1543
+    "hvien",          // 1544
+    "hvictl",         // 1545
+    "henvcfg",        // 1546
+    "unknown",        // 1547
+    "hstateen0",      // 1548
+    "hstateen1",      // 1549
+    "hstateen2",      // 1550
+    "hstateen3",      // 1551
+    "unknown",        // 1552
+    "unknown",        // 1553
+    "unknown",        // 1554
+    "hidelegh",       // 1555
+    "unknown",        // 1556
+    "htimedeltah",    // 1557
+    "unknown",        // 1558
+    "unknown",        // 1559
+    "hvienh",         // 1560
+    "unknown",        // 1561
+    "henvcfgh",       // 1562
+    "unknown",        // 1563
+    "hstateen0h",     // 1564
+    "hstateen1h",     // 1565
+    "hstateen2h",     // 1566
+    "hstateen3h",     // 1567
+    "unknown",        // 1568
+    "unknown",        // 1569
+    "unknown",        // 1570
+    "unknown",        // 1571
+    "unknown",        // 1572
+    "unknown",        // 1573
+    "unknown",        // 1574
+    "unknown",        // 1575
+    "unknown",        // 1576
+    "unknown",        // 1577
+    "unknown",        // 1578
+    "unknown",        // 1579
+    "unknown",        // 1580
+    "unknown",        // 1581
+    "unknown",        // 1582
+    "unknown",        // 1583
+    "unknown",        // 1584
+    "unknown",        // 1585
+    "unknown",        // 1586
+    "unknown",        // 1587
+    "unknown",        // 1588
+    "unknown",        // 1589
+    "unknown",        // 1590
+    "unknown",        // 1591
+    "unknown",        // 1592
+    "unknown",        // 1593
+    "unknown",        // 1594
+    "unknown",        // 1595
+    "unknown",        // 1596
+    "unknown",        // 1597
+    "unknown",        // 1598
+    "unknown",        // 1599
+    "unknown",        // 1600
+    "unknown",        // 1601
+    "unknown",        // 1602
+    "htval",          // 1603
+    "hip",            // 1604
+    "hvip",           // 1605
+    "hviprio1",       // 1606
+    "hviprio2",       // 1607
+    "unknown",        // 1608
+    "unknown",        // 1609
+    "htinst",         // 1610
+    "unknown",        // 1611
+    "unknown",        // 1612
+    "unknown",        // 1613
+    "unknown",        // 1614
+    "unknown",        // 1615
+    "unknown",        // 1616
+    "unknown",        // 1617
+    "unknown",        // 1618
+    "unknown",        // 1619
+    "unknown",        // 1620
+    "hviph",          // 1621
+    "hviprio1h",      // 1622
+    "hviprio2h",      // 1623
+    "unknown",        // 1624
+    "unknown",        // 1625
+    "unknown",        // 1626
+    "unknown",        // 1627
+    "unknown",        // 1628
+    "unknown",        // 1629
+    "unknown",        // 1630
+    "unknown",        // 1631
+    "unknown",        // 1632
+    "unknown",        // 1633
+    "unknown",        // 1634
+    "unknown",        // 1635
+    "unknown",        // 1636
+    "unknown",        // 1637
+    "unknown",        // 1638
+    "unknown",        // 1639
+    "unknown",        // 1640
+    "unknown",        // 1641
+    "unknown",        // 1642
+    "unknown",        // 1643
+    "unknown",        // 1644
+    "unknown",        // 1645
+    "unknown",        // 1646
+    "unknown",        // 1647
+    "unknown",        // 1648
+    "unknown",        // 1649
+    "unknown",        // 1650
+    "unknown",        // 1651
+    "unknown",        // 1652
+    "unknown",        // 1653
+    "unknown",        // 1654
+    "unknown",        // 1655
+    "unknown",        // 1656
+    "unknown",        // 1657
+    "unknown",        // 1658
+    "unknown",        // 1659
+    "unknown",        // 1660
+    "unknown",        // 1661
+    "unknown",        // 1662
+    "unknown",        // 1663
+    "hgatp",          // 1664
+    "unknown",        // 1665
+    "unknown",        // 1666
+    "unknown",        // 1667
+    "unknown",        // 1668
+    "unknown",        // 1669
+    "unknown",        // 1670
+    "unknown",        // 1671
+    "unknown",        // 1672
+    "unknown",        // 1673
+    "unknown",        // 1674
+    "unknown",        // 1675
+    "unknown",        // 1676
+    "unknown",        // 1677
+    "unknown",        // 1678
+    "unknown",        // 1679
+    "unknown",        // 1680
+    "unknown",        // 1681
+    "unknown",        // 1682
+    "unknown",        // 1683
+    "unknown",        // 1684
+    "unknown",        // 1685
+    "unknown",        // 1686
+    "unknown",        // 1687
+    "unknown",        // 1688
+    "unknown",        // 1689
+    "unknown",        // 1690
+    "unknown",        // 1691
+    "unknown",        // 1692
+    "unknown",        // 1693
+    "unknown",        // 1694
+    "unknown",        // 1695
+    "unknown",        // 1696
+    "unknown",        // 1697
+    "unknown",        // 1698
+    "unknown",        // 1699
+    "unknown",        // 1700
+    "unknown",        // 1701
+    "unknown",        // 1702
+    "unknown",        // 1703
+    "hcontext",       // 1704
+    "unknown",        // 1705
+    "unknown",        // 1706
+    "unknown",        // 1707
+    "unknown",        // 1708
+    "unknown",        // 1709
+    "unknown",        // 1710
+    "unknown",        // 1711
+    "unknown",        // 1712
+    "unknown",        // 1713
+    "unknown",        // 1714
+    "unknown",        // 1715
+    "unknown",        // 1716
+    "unknown",        // 1717
+    "unknown",        // 1718
+    "unknown",        // 1719
+    "unknown",        // 1720
+    "unknown",        // 1721
+    "unknown",        // 1722
+    "unknown",        // 1723
+    "unknown",        // 1724
+    "unknown",        // 1725
+    "unknown",        // 1726
+    "unknown",        // 1727
+    "unknown",        // 1728
+    "unknown",        // 1729
+    "unknown",        // 1730
+    "unknown",        // 1731
+    "unknown",        // 1732
+    "unknown",        // 1733
+    "unknown",        // 1734
+    "unknown",        // 1735
+    "unknown",        // 1736
+    "unknown",        // 1737
+    "unknown",        // 1738
+    "unknown",        // 1739
+    "unknown",        // 1740
+    "unknown",        // 1741
+    "unknown",        // 1742
+    "unknown",        // 1743
+    "unknown",        // 1744
+    "unknown",        // 1745
+    "unknown",        // 1746
+    "unknown",        // 1747
+    "unknown",        // 1748
+    "unknown",        // 1749
+    "unknown",        // 1750
+    "unknown",        // 1751
+    "unknown",        // 1752
+    "unknown",        // 1753
+    "unknown",        // 1754
+    "unknown",        // 1755
+    "unknown",        // 1756
+    "unknown",        // 1757
+    "unknown",        // 1758
+    "unknown",        // 1759
+    "unknown",        // 1760
+    "unknown",        // 1761
+    "unknown",        // 1762
+    "unknown",        // 1763
+    "unknown",        // 1764
+    "unknown",        // 1765
+    "unknown",        // 1766
+    "unknown",        // 1767
+    "unknown",        // 1768
+    "unknown",        // 1769
+    "unknown",        // 1770
+    "unknown",        // 1771
+    "unknown",        // 1772
+    "unknown",        // 1773
+    "unknown",        // 1774
+    "unknown",        // 1775
+    "unknown",        // 1776
+    "unknown",        // 1777
+    "unknown",        // 1778
+    "unknown",        // 1779
+    "unknown",        // 1780
+    "unknown",        // 1781
+    "unknown",        // 1782
+    "unknown",        // 1783
+    "unknown",        // 1784
+    "unknown",        // 1785
+    "unknown",        // 1786
+    "unknown",        // 1787
+    "unknown",        // 1788
+    "unknown",        // 1789
+    "unknown",        // 1790
+    "unknown",        // 1791
+    "unknown",        // 1792
+    "unknown",        // 1793
+    "unknown",        // 1794
+    "unknown",        // 1795
+    "unknown",        // 1796
+    "unknown",        // 1797
+    "unknown",        // 1798
+    "unknown",        // 1799
+    "unknown",        // 1800
+    "unknown",        // 1801
+    "unknown",        // 1802
+    "unknown",        // 1803
+    "unknown",        // 1804
+    "unknown",        // 1805
+    "unknown",        // 1806
+    "unknown",        // 1807
+    "unknown",        // 1808
+    "unknown",        // 1809
+    "unknown",        // 1810
+    "unknown",        // 1811
+    "unknown",        // 1812
+    "unknown",        // 1813
+    "unknown",        // 1814
+    "unknown",        // 1815
+    "unknown",        // 1816
+    "unknown",        // 1817
+    "unknown",        // 1818
+    "unknown",        // 1819
+    "unknown",        // 1820
+    "unknown",        // 1821
+    "unknown",        // 1822
+    "unknown",        // 1823
+    "unknown",        // 1824
+    "mcyclecfgh",     // 1825
+    "minstretcfgh",   // 1826
+    "mhpmevent3h",    // 1827
+    "mhpmevent4h",    // 1828
+    "mhpmevent5h",    // 1829
+    "mhpmevent6h",    // 1830
+    "mhpmevent7h",    // 1831
+    "mhpmevent8h",    // 1832
+    "mhpmevent9h",    // 1833
+    "mhpmevent10h",   // 1834
+    "mhpmevent11h",   // 1835
+    "mhpmevent12h",   // 1836
+    "mhpmevent13h",   // 1837
+    "mhpmevent14h",   // 1838
+    "mhpmevent15h",   // 1839
+    "mhpmevent16h",   // 1840
+    "mhpmevent17h",   // 1841
+    "mhpmevent18h",   // 1842
+    "mhpmevent19h",   // 1843
+    "mhpmevent20h",   // 1844
+    "mhpmevent21h",   // 1845
+    "mhpmevent22h",   // 1846
+    "mhpmevent23h",   // 1847
+    "mhpmevent24h",   // 1848
+    "mhpmevent25h",   // 1849
+    "mhpmevent26h",   // 1850
+    "mhpmevent27h",   // 1851
+    "mhpmevent28h",   // 1852
+    "mhpmevent29h",   // 1853
+    "mhpmevent30h",   // 1854
+    "mhpmevent31h",   // 1855
+    "mnscratch",      // 1856
+    "mnepc",          // 1857
+    "mncause",        // 1858
+    "unknown",        // 1859
+    "mnstatus",       // 1860
+    "unknown",        // 1861
+    "unknown",        // 1862
+    "mseccfg",        // 1863
+    "unknown",        // 1864
+    "unknown",        // 1865
+    "unknown",        // 1866
+    "unknown",        // 1867
+    "unknown",        // 1868
+    "unknown",        // 1869
+    "unknown",        // 1870
+    "unknown",        // 1871
+    "unknown",        // 1872
+    "unknown",        // 1873
+    "unknown",        // 1874
+    "unknown",        // 1875
+    "unknown",        // 1876
+    "unknown",        // 1877
+    "unknown",        // 1878
+    "mseccfgh",       // 1879
+    "unknown",        // 1880
+    "unknown",        // 1881
+    "unknown",        // 1882
+    "unknown",        // 1883
+    "unknown",        // 1884
+    "unknown",        // 1885
+    "unknown",        // 1886
+    "unknown",        // 1887
+    "unknown",        // 1888
+    "unknown",        // 1889
+    "unknown",        // 1890
+    "unknown",        // 1891
+    "unknown",        // 1892
+    "unknown",        // 1893
+    "unknown",        // 1894
+    "unknown",        // 1895
+    "unknown",        // 1896
+    "unknown",        // 1897
+    "unknown",        // 1898
+    "unknown",        // 1899
+    "unknown",        // 1900
+    "unknown",        // 1901
+    "unknown",        // 1902
+    "unknown",        // 1903
+    "unknown",        // 1904
+    "unknown",        // 1905
+    "unknown",        // 1906
+    "unknown",        // 1907
+    "unknown",        // 1908
+    "unknown",        // 1909
+    "unknown",        // 1910
+    "unknown",        // 1911
+    "unknown",        // 1912
+    "unknown",        // 1913
+    "unknown",        // 1914
+    "unknown",        // 1915
+    "unknown",        // 1916
+    "unknown",        // 1917
+    "unknown",        // 1918
+    "unknown",        // 1919
+    "unknown",        // 1920
+    "unknown",        // 1921
+    "unknown",        // 1922
+    "unknown",        // 1923
+    "unknown",        // 1924
+    "unknown",        // 1925
+    "unknown",        // 1926
+    "unknown",        // 1927
+    "unknown",        // 1928
+    "unknown",        // 1929
+    "unknown",        // 1930
+    "unknown",        // 1931
+    "unknown",        // 1932
+    "unknown",        // 1933
+    "unknown",        // 1934
+    "unknown",        // 1935
+    "unknown",        // 1936
+    "unknown",        // 1937
+    "unknown",        // 1938
+    "unknown",        // 1939
+    "unknown",        // 1940
+    "unknown",        // 1941
+    "unknown",        // 1942
+    "unknown",        // 1943
+    "unknown",        // 1944
+    "unknown",        // 1945
+    "unknown",        // 1946
+    "unknown",        // 1947
+    "unknown",        // 1948
+    "unknown",        // 1949
+    "unknown",        // 1950
+    "unknown",        // 1951
+    "tselect",        // 1952
+    "tdata1",         // 1953
+    "tdata2",         // 1954
+    "tdata3",         // 1955
+    "tinfo",          // 1956
+    "tcontrol",       // 1957
+    "unknown",        // 1958
+    "unknown",        // 1959
+    "mcontext",       // 1960
+    "unknown",        // 1961
+    "mscontext",      // 1962
+    "unknown",        // 1963
+    "unknown",        // 1964
+    "unknown",        // 1965
+    "unknown",        // 1966
+    "unknown",        // 1967
+    "dcsr",           // 1968
+    "dpc",            // 1969
+    "dscratch0",      // 1970
+    "dscratch1",      // 1971
+    "unknown",        // 1972
+    "unknown",        // 1973
+    "unknown",        // 1974
+    "unknown",        // 1975
+    "unknown",        // 1976
+    "unknown",        // 1977
+    "unknown",        // 1978
+    "unknown",        // 1979
+    "unknown",        // 1980
+    "unknown",        // 1981
+    "unknown",        // 1982
+    "unknown",        // 1983
+    "unknown",        // 1984
+    "unknown",        // 1985
+    "unknown",        // 1986
+    "unknown",        // 1987
+    "unknown",        // 1988
+    "unknown",        // 1989
+    "unknown",        // 1990
+    "unknown",        // 1991
+    "unknown",        // 1992
+    "unknown",        // 1993
+    "unknown",        // 1994
+    "unknown",        // 1995
+    "unknown",        // 1996
+    "unknown",        // 1997
+    "unknown",        // 1998
+    "unknown",        // 1999
+    "unknown",        // 2000
+    "unknown",        // 2001
+    "unknown",        // 2002
+    "unknown",        // 2003
+    "unknown",        // 2004
+    "unknown",        // 2005
+    "unknown",        // 2006
+    "unknown",        // 2007
+    "unknown",        // 2008
+    "unknown",        // 2009
+    "unknown",        // 2010
+    "unknown",        // 2011
+    "unknown",        // 2012
+    "unknown",        // 2013
+    "unknown",        // 2014
+    "unknown",        // 2015
+    "unknown",        // 2016
+    "unknown",        // 2017
+    "unknown",        // 2018
+    "unknown",        // 2019
+    "unknown",        // 2020
+    "unknown",        // 2021
+    "unknown",        // 2022
+    "unknown",        // 2023
+    "unknown",        // 2024
+    "unknown",        // 2025
+    "unknown",        // 2026
+    "unknown",        // 2027
+    "unknown",        // 2028
+    "unknown",        // 2029
+    "unknown",        // 2030
+    "unknown",        // 2031
+    "unknown",        // 2032
+    "unknown",        // 2033
+    "unknown",        // 2034
+    "unknown",        // 2035
+    "unknown",        // 2036
+    "unknown",        // 2037
+    "unknown",        // 2038
+    "unknown",        // 2039
+    "unknown",        // 2040
+    "unknown",        // 2041
+    "unknown",        // 2042
+    "unknown",        // 2043
+    "unknown",        // 2044
+    "unknown",        // 2045
+    "unknown",        // 2046
+    "unknown",        // 2047
+    "unknown",        // 2048
+    "unknown",        // 2049
+    "unknown",        // 2050
+    "unknown",        // 2051
+    "unknown",        // 2052
+    "unknown",        // 2053
+    "unknown",        // 2054
+    "unknown",        // 2055
+    "unknown",        // 2056
+    "unknown",        // 2057
+    "unknown",        // 2058
+    "unknown",        // 2059
+    "unknown",        // 2060
+    "unknown",        // 2061
+    "unknown",        // 2062
+    "unknown",        // 2063
+    "unknown",        // 2064
+    "unknown",        // 2065
+    "unknown",        // 2066
+    "unknown",        // 2067
+    "unknown",        // 2068
+    "unknown",        // 2069
+    "unknown",        // 2070
+    "unknown",        // 2071
+    "unknown",        // 2072
+    "unknown",        // 2073
+    "unknown",        // 2074
+    "unknown",        // 2075
+    "unknown",        // 2076
+    "unknown",        // 2077
+    "unknown",        // 2078
+    "unknown",        // 2079
+    "unknown",        // 2080
+    "unknown",        // 2081
+    "unknown",        // 2082
+    "unknown",        // 2083
+    "unknown",        // 2084
+    "unknown",        // 2085
+    "unknown",        // 2086
+    "unknown",        // 2087
+    "unknown",        // 2088
+    "unknown",        // 2089
+    "unknown",        // 2090
+    "unknown",        // 2091
+    "unknown",        // 2092
+    "unknown",        // 2093
+    "unknown",        // 2094
+    "unknown",        // 2095
+    "unknown",        // 2096
+    "unknown",        // 2097
+    "unknown",        // 2098
+    "unknown",        // 2099
+    "unknown",        // 2100
+    "unknown",        // 2101
+    "unknown",        // 2102
+    "unknown",        // 2103
+    "unknown",        // 2104
+    "unknown",        // 2105
+    "unknown",        // 2106
+    "unknown",        // 2107
+    "unknown",        // 2108
+    "unknown",        // 2109
+    "unknown",        // 2110
+    "unknown",        // 2111
+    "unknown",        // 2112
+    "unknown",        // 2113
+    "unknown",        // 2114
+    "unknown",        // 2115
+    "unknown",        // 2116
+    "unknown",        // 2117
+    "unknown",        // 2118
+    "unknown",        // 2119
+    "unknown",        // 2120
+    "unknown",        // 2121
+    "unknown",        // 2122
+    "unknown",        // 2123
+    "unknown",        // 2124
+    "unknown",        // 2125
+    "unknown",        // 2126
+    "unknown",        // 2127
+    "unknown",        // 2128
+    "unknown",        // 2129
+    "unknown",        // 2130
+    "unknown",        // 2131
+    "unknown",        // 2132
+    "unknown",        // 2133
+    "unknown",        // 2134
+    "unknown",        // 2135
+    "unknown",        // 2136
+    "unknown",        // 2137
+    "unknown",        // 2138
+    "unknown",        // 2139
+    "unknown",        // 2140
+    "unknown",        // 2141
+    "unknown",        // 2142
+    "unknown",        // 2143
+    "unknown",        // 2144
+    "unknown",        // 2145
+    "unknown",        // 2146
+    "unknown",        // 2147
+    "unknown",        // 2148
+    "unknown",        // 2149
+    "unknown",        // 2150
+    "unknown",        // 2151
+    "unknown",        // 2152
+    "unknown",        // 2153
+    "unknown",        // 2154
+    "unknown",        // 2155
+    "unknown",        // 2156
+    "unknown",        // 2157
+    "unknown",        // 2158
+    "unknown",        // 2159
+    "unknown",        // 2160
+    "unknown",        // 2161
+    "unknown",        // 2162
+    "unknown",        // 2163
+    "unknown",        // 2164
+    "unknown",        // 2165
+    "unknown",        // 2166
+    "unknown",        // 2167
+    "unknown",        // 2168
+    "unknown",        // 2169
+    "unknown",        // 2170
+    "unknown",        // 2171
+    "unknown",        // 2172
+    "unknown",        // 2173
+    "unknown",        // 2174
+    "unknown",        // 2175
+    "unknown",        // 2176
+    "unknown",        // 2177
+    "unknown",        // 2178
+    "unknown",        // 2179
+    "unknown",        // 2180
+    "unknown",        // 2181
+    "unknown",        // 2182
+    "unknown",        // 2183
+    "unknown",        // 2184
+    "unknown",        // 2185
+    "unknown",        // 2186
+    "unknown",        // 2187
+    "unknown",        // 2188
+    "unknown",        // 2189
+    "unknown",        // 2190
+    "unknown",        // 2191
+    "unknown",        // 2192
+    "unknown",        // 2193
+    "unknown",        // 2194
+    "unknown",        // 2195
+    "unknown",        // 2196
+    "unknown",        // 2197
+    "unknown",        // 2198
+    "unknown",        // 2199
+    "unknown",        // 2200
+    "unknown",        // 2201
+    "unknown",        // 2202
+    "unknown",        // 2203
+    "unknown",        // 2204
+    "unknown",        // 2205
+    "unknown",        // 2206
+    "unknown",        // 2207
+    "unknown",        // 2208
+    "unknown",        // 2209
+    "unknown",        // 2210
+    "unknown",        // 2211
+    "unknown",        // 2212
+    "unknown",        // 2213
+    "unknown",        // 2214
+    "unknown",        // 2215
+    "unknown",        // 2216
+    "unknown",        // 2217
+    "unknown",        // 2218
+    "unknown",        // 2219
+    "unknown",        // 2220
+    "unknown",        // 2221
+    "unknown",        // 2222
+    "unknown",        // 2223
+    "unknown",        // 2224
+    "unknown",        // 2225
+    "unknown",        // 2226
+    "unknown",        // 2227
+    "unknown",        // 2228
+    "unknown",        // 2229
+    "unknown",        // 2230
+    "unknown",        // 2231
+    "unknown",        // 2232
+    "unknown",        // 2233
+    "unknown",        // 2234
+    "unknown",        // 2235
+    "unknown",        // 2236
+    "unknown",        // 2237
+    "unknown",        // 2238
+    "unknown",        // 2239
+    "unknown",        // 2240
+    "unknown",        // 2241
+    "unknown",        // 2242
+    "unknown",        // 2243
+    "unknown",        // 2244
+    "unknown",        // 2245
+    "unknown",        // 2246
+    "unknown",        // 2247
+    "unknown",        // 2248
+    "unknown",        // 2249
+    "unknown",        // 2250
+    "unknown",        // 2251
+    "unknown",        // 2252
+    "unknown",        // 2253
+    "unknown",        // 2254
+    "unknown",        // 2255
+    "unknown",        // 2256
+    "unknown",        // 2257
+    "unknown",        // 2258
+    "unknown",        // 2259
+    "unknown",        // 2260
+    "unknown",        // 2261
+    "unknown",        // 2262
+    "unknown",        // 2263
+    "unknown",        // 2264
+    "unknown",        // 2265
+    "unknown",        // 2266
+    "unknown",        // 2267
+    "unknown",        // 2268
+    "unknown",        // 2269
+    "unknown",        // 2270
+    "unknown",        // 2271
+    "unknown",        // 2272
+    "unknown",        // 2273
+    "unknown",        // 2274
+    "unknown",        // 2275
+    "unknown",        // 2276
+    "unknown",        // 2277
+    "unknown",        // 2278
+    "unknown",        // 2279
+    "unknown",        // 2280
+    "unknown",        // 2281
+    "unknown",        // 2282
+    "unknown",        // 2283
+    "unknown",        // 2284
+    "unknown",        // 2285
+    "unknown",        // 2286
+    "unknown",        // 2287
+    "unknown",        // 2288
+    "unknown",        // 2289
+    "unknown",        // 2290
+    "unknown",        // 2291
+    "unknown",        // 2292
+    "unknown",        // 2293
+    "unknown",        // 2294
+    "unknown",        // 2295
+    "unknown",        // 2296
+    "unknown",        // 2297
+    "unknown",        // 2298
+    "unknown",        // 2299
+    "unknown",        // 2300
+    "unknown",        // 2301
+    "unknown",        // 2302
+    "unknown",        // 2303
+    "unknown",        // 2304
+    "unknown",        // 2305
+    "unknown",        // 2306
+    "unknown",        // 2307
+    "unknown",        // 2308
+    "unknown",        // 2309
+    "unknown",        // 2310
+    "unknown",        // 2311
+    "unknown",        // 2312
+    "unknown",        // 2313
+    "unknown",        // 2314
+    "unknown",        // 2315
+    "unknown",        // 2316
+    "unknown",        // 2317
+    "unknown",        // 2318
+    "unknown",        // 2319
+    "unknown",        // 2320
+    "unknown",        // 2321
+    "unknown",        // 2322
+    "unknown",        // 2323
+    "unknown",        // 2324
+    "unknown",        // 2325
+    "unknown",        // 2326
+    "unknown",        // 2327
+    "unknown",        // 2328
+    "unknown",        // 2329
+    "unknown",        // 2330
+    "unknown",        // 2331
+    "unknown",        // 2332
+    "unknown",        // 2333
+    "unknown",        // 2334
+    "unknown",        // 2335
+    "unknown",        // 2336
+    "unknown",        // 2337
+    "unknown",        // 2338
+    "unknown",        // 2339
+    "unknown",        // 2340
+    "unknown",        // 2341
+    "unknown",        // 2342
+    "unknown",        // 2343
+    "unknown",        // 2344
+    "unknown",        // 2345
+    "unknown",        // 2346
+    "unknown",        // 2347
+    "unknown",        // 2348
+    "unknown",        // 2349
+    "unknown",        // 2350
+    "unknown",        // 2351
+    "unknown",        // 2352
+    "unknown",        // 2353
+    "unknown",        // 2354
+    "unknown",        // 2355
+    "unknown",        // 2356
+    "unknown",        // 2357
+    "unknown",        // 2358
+    "unknown",        // 2359
+    "unknown",        // 2360
+    "unknown",        // 2361
+    "unknown",        // 2362
+    "unknown",        // 2363
+    "unknown",        // 2364
+    "unknown",        // 2365
+    "unknown",        // 2366
+    "unknown",        // 2367
+    "unknown",        // 2368
+    "unknown",        // 2369
+    "unknown",        // 2370
+    "unknown",        // 2371
+    "unknown",        // 2372
+    "unknown",        // 2373
+    "unknown",        // 2374
+    "unknown",        // 2375
+    "unknown",        // 2376
+    "unknown",        // 2377
+    "unknown",        // 2378
+    "unknown",        // 2379
+    "unknown",        // 2380
+    "unknown",        // 2381
+    "unknown",        // 2382
+    "unknown",        // 2383
+    "unknown",        // 2384
+    "unknown",        // 2385
+    "unknown",        // 2386
+    "unknown",        // 2387
+    "unknown",        // 2388
+    "unknown",        // 2389
+    "unknown",        // 2390
+    "unknown",        // 2391
+    "unknown",        // 2392
+    "unknown",        // 2393
+    "unknown",        // 2394
+    "unknown",        // 2395
+    "unknown",        // 2396
+    "unknown",        // 2397
+    "unknown",        // 2398
+    "unknown",        // 2399
+    "unknown",        // 2400
+    "unknown",        // 2401
+    "unknown",        // 2402
+    "unknown",        // 2403
+    "unknown",        // 2404
+    "unknown",        // 2405
+    "unknown",        // 2406
+    "unknown",        // 2407
+    "unknown",        // 2408
+    "unknown",        // 2409
+    "unknown",        // 2410
+    "unknown",        // 2411
+    "unknown",        // 2412
+    "unknown",        // 2413
+    "unknown",        // 2414
+    "unknown",        // 2415
+    "unknown",        // 2416
+    "unknown",        // 2417
+    "unknown",        // 2418
+    "unknown",        // 2419
+    "unknown",        // 2420
+    "unknown",        // 2421
+    "unknown",        // 2422
+    "unknown",        // 2423
+    "unknown",        // 2424
+    "unknown",        // 2425
+    "unknown",        // 2426
+    "unknown",        // 2427
+    "unknown",        // 2428
+    "unknown",        // 2429
+    "unknown",        // 2430
+    "unknown",        // 2431
+    "unknown",        // 2432
+    "unknown",        // 2433
+    "unknown",        // 2434
+    "unknown",        // 2435
+    "unknown",        // 2436
+    "unknown",        // 2437
+    "unknown",        // 2438
+    "unknown",        // 2439
+    "unknown",        // 2440
+    "unknown",        // 2441
+    "unknown",        // 2442
+    "unknown",        // 2443
+    "unknown",        // 2444
+    "unknown",        // 2445
+    "unknown",        // 2446
+    "unknown",        // 2447
+    "unknown",        // 2448
+    "unknown",        // 2449
+    "unknown",        // 2450
+    "unknown",        // 2451
+    "unknown",        // 2452
+    "unknown",        // 2453
+    "unknown",        // 2454
+    "unknown",        // 2455
+    "unknown",        // 2456
+    "unknown",        // 2457
+    "unknown",        // 2458
+    "unknown",        // 2459
+    "unknown",        // 2460
+    "unknown",        // 2461
+    "unknown",        // 2462
+    "unknown",        // 2463
+    "unknown",        // 2464
+    "unknown",        // 2465
+    "unknown",        // 2466
+    "unknown",        // 2467
+    "unknown",        // 2468
+    "unknown",        // 2469
+    "unknown",        // 2470
+    "unknown",        // 2471
+    "unknown",        // 2472
+    "unknown",        // 2473
+    "unknown",        // 2474
+    "unknown",        // 2475
+    "unknown",        // 2476
+    "unknown",        // 2477
+    "unknown",        // 2478
+    "unknown",        // 2479
+    "unknown",        // 2480
+    "unknown",        // 2481
+    "unknown",        // 2482
+    "unknown",        // 2483
+    "unknown",        // 2484
+    "unknown",        // 2485
+    "unknown",        // 2486
+    "unknown",        // 2487
+    "unknown",        // 2488
+    "unknown",        // 2489
+    "unknown",        // 2490
+    "unknown",        // 2491
+    "unknown",        // 2492
+    "unknown",        // 2493
+    "unknown",        // 2494
+    "unknown",        // 2495
+    "unknown",        // 2496
+    "unknown",        // 2497
+    "unknown",        // 2498
+    "unknown",        // 2499
+    "unknown",        // 2500
+    "unknown",        // 2501
+    "unknown",        // 2502
+    "unknown",        // 2503
+    "unknown",        // 2504
+    "unknown",        // 2505
+    "unknown",        // 2506
+    "unknown",        // 2507
+    "unknown",        // 2508
+    "unknown",        // 2509
+    "unknown",        // 2510
+    "unknown",        // 2511
+    "unknown",        // 2512
+    "unknown",        // 2513
+    "unknown",        // 2514
+    "unknown",        // 2515
+    "unknown",        // 2516
+    "unknown",        // 2517
+    "unknown",        // 2518
+    "unknown",        // 2519
+    "unknown",        // 2520
+    "unknown",        // 2521
+    "unknown",        // 2522
+    "unknown",        // 2523
+    "unknown",        // 2524
+    "unknown",        // 2525
+    "unknown",        // 2526
+    "unknown",        // 2527
+    "unknown",        // 2528
+    "unknown",        // 2529
+    "unknown",        // 2530
+    "unknown",        // 2531
+    "unknown",        // 2532
+    "unknown",        // 2533
+    "unknown",        // 2534
+    "unknown",        // 2535
+    "unknown",        // 2536
+    "unknown",        // 2537
+    "unknown",        // 2538
+    "unknown",        // 2539
+    "unknown",        // 2540
+    "unknown",        // 2541
+    "unknown",        // 2542
+    "unknown",        // 2543
+    "unknown",        // 2544
+    "unknown",        // 2545
+    "unknown",        // 2546
+    "unknown",        // 2547
+    "unknown",        // 2548
+    "unknown",        // 2549
+    "unknown",        // 2550
+    "unknown",        // 2551
+    "unknown",        // 2552
+    "unknown",        // 2553
+    "unknown",        // 2554
+    "unknown",        // 2555
+    "unknown",        // 2556
+    "unknown",        // 2557
+    "unknown",        // 2558
+    "unknown",        // 2559
+    "unknown",        // 2560
+    "unknown",        // 2561
+    "unknown",        // 2562
+    "unknown",        // 2563
+    "unknown",        // 2564
+    "unknown",        // 2565
+    "unknown",        // 2566
+    "unknown",        // 2567
+    "unknown",        // 2568
+    "unknown",        // 2569
+    "unknown",        // 2570
+    "unknown",        // 2571
+    "unknown",        // 2572
+    "unknown",        // 2573
+    "unknown",        // 2574
+    "unknown",        // 2575
+    "unknown",        // 2576
+    "unknown",        // 2577
+    "unknown",        // 2578
+    "unknown",        // 2579
+    "unknown",        // 2580
+    "unknown",        // 2581
+    "unknown",        // 2582
+    "unknown",        // 2583
+    "unknown",        // 2584
+    "unknown",        // 2585
+    "unknown",        // 2586
+    "unknown",        // 2587
+    "unknown",        // 2588
+    "unknown",        // 2589
+    "unknown",        // 2590
+    "unknown",        // 2591
+    "unknown",        // 2592
+    "unknown",        // 2593
+    "unknown",        // 2594
+    "unknown",        // 2595
+    "unknown",        // 2596
+    "unknown",        // 2597
+    "unknown",        // 2598
+    "unknown",        // 2599
+    "unknown",        // 2600
+    "unknown",        // 2601
+    "unknown",        // 2602
+    "unknown",        // 2603
+    "unknown",        // 2604
+    "unknown",        // 2605
+    "unknown",        // 2606
+    "unknown",        // 2607
+    "unknown",        // 2608
+    "unknown",        // 2609
+    "unknown",        // 2610
+    "unknown",        // 2611
+    "unknown",        // 2612
+    "unknown",        // 2613
+    "unknown",        // 2614
+    "unknown",        // 2615
+    "unknown",        // 2616
+    "unknown",        // 2617
+    "unknown",        // 2618
+    "unknown",        // 2619
+    "unknown",        // 2620
+    "unknown",        // 2621
+    "unknown",        // 2622
+    "unknown",        // 2623
+    "unknown",        // 2624
+    "unknown",        // 2625
+    "unknown",        // 2626
+    "unknown",        // 2627
+    "unknown",        // 2628
+    "unknown",        // 2629
+    "unknown",        // 2630
+    "unknown",        // 2631
+    "unknown",        // 2632
+    "unknown",        // 2633
+    "unknown",        // 2634
+    "unknown",        // 2635
+    "unknown",        // 2636
+    "unknown",        // 2637
+    "unknown",        // 2638
+    "unknown",        // 2639
+    "unknown",        // 2640
+    "unknown",        // 2641
+    "unknown",        // 2642
+    "unknown",        // 2643
+    "unknown",        // 2644
+    "unknown",        // 2645
+    "unknown",        // 2646
+    "unknown",        // 2647
+    "unknown",        // 2648
+    "unknown",        // 2649
+    "unknown",        // 2650
+    "unknown",        // 2651
+    "unknown",        // 2652
+    "unknown",        // 2653
+    "unknown",        // 2654
+    "unknown",        // 2655
+    "unknown",        // 2656
+    "unknown",        // 2657
+    "unknown",        // 2658
+    "unknown",        // 2659
+    "unknown",        // 2660
+    "unknown",        // 2661
+    "unknown",        // 2662
+    "unknown",        // 2663
+    "unknown",        // 2664
+    "unknown",        // 2665
+    "unknown",        // 2666
+    "unknown",        // 2667
+    "unknown",        // 2668
+    "unknown",        // 2669
+    "unknown",        // 2670
+    "unknown",        // 2671
+    "unknown",        // 2672
+    "unknown",        // 2673
+    "unknown",        // 2674
+    "unknown",        // 2675
+    "unknown",        // 2676
+    "unknown",        // 2677
+    "unknown",        // 2678
+    "unknown",        // 2679
+    "unknown",        // 2680
+    "unknown",        // 2681
+    "unknown",        // 2682
+    "unknown",        // 2683
+    "unknown",        // 2684
+    "unknown",        // 2685
+    "unknown",        // 2686
+    "unknown",        // 2687
+    "unknown",        // 2688
+    "unknown",        // 2689
+    "unknown",        // 2690
+    "unknown",        // 2691
+    "unknown",        // 2692
+    "unknown",        // 2693
+    "unknown",        // 2694
+    "unknown",        // 2695
+    "unknown",        // 2696
+    "unknown",        // 2697
+    "unknown",        // 2698
+    "unknown",        // 2699
+    "unknown",        // 2700
+    "unknown",        // 2701
+    "unknown",        // 2702
+    "unknown",        // 2703
+    "unknown",        // 2704
+    "unknown",        // 2705
+    "unknown",        // 2706
+    "unknown",        // 2707
+    "unknown",        // 2708
+    "unknown",        // 2709
+    "unknown",        // 2710
+    "unknown",        // 2711
+    "unknown",        // 2712
+    "unknown",        // 2713
+    "unknown",        // 2714
+    "unknown",        // 2715
+    "unknown",        // 2716
+    "unknown",        // 2717
+    "unknown",        // 2718
+    "unknown",        // 2719
+    "unknown",        // 2720
+    "unknown",        // 2721
+    "unknown",        // 2722
+    "unknown",        // 2723
+    "unknown",        // 2724
+    "unknown",        // 2725
+    "unknown",        // 2726
+    "unknown",        // 2727
+    "unknown",        // 2728
+    "unknown",        // 2729
+    "unknown",        // 2730
+    "unknown",        // 2731
+    "unknown",        // 2732
+    "unknown",        // 2733
+    "unknown",        // 2734
+    "unknown",        // 2735
+    "unknown",        // 2736
+    "unknown",        // 2737
+    "unknown",        // 2738
+    "unknown",        // 2739
+    "unknown",        // 2740
+    "unknown",        // 2741
+    "unknown",        // 2742
+    "unknown",        // 2743
+    "unknown",        // 2744
+    "unknown",        // 2745
+    "unknown",        // 2746
+    "unknown",        // 2747
+    "unknown",        // 2748
+    "unknown",        // 2749
+    "unknown",        // 2750
+    "unknown",        // 2751
+    "unknown",        // 2752
+    "unknown",        // 2753
+    "unknown",        // 2754
+    "unknown",        // 2755
+    "unknown",        // 2756
+    "unknown",        // 2757
+    "unknown",        // 2758
+    "unknown",        // 2759
+    "unknown",        // 2760
+    "unknown",        // 2761
+    "unknown",        // 2762
+    "unknown",        // 2763
+    "unknown",        // 2764
+    "unknown",        // 2765
+    "unknown",        // 2766
+    "unknown",        // 2767
+    "unknown",        // 2768
+    "unknown",        // 2769
+    "unknown",        // 2770
+    "unknown",        // 2771
+    "unknown",        // 2772
+    "unknown",        // 2773
+    "unknown",        // 2774
+    "unknown",        // 2775
+    "unknown",        // 2776
+    "unknown",        // 2777
+    "unknown",        // 2778
+    "unknown",        // 2779
+    "unknown",        // 2780
+    "unknown",        // 2781
+    "unknown",        // 2782
+    "unknown",        // 2783
+    "unknown",        // 2784
+    "unknown",        // 2785
+    "unknown",        // 2786
+    "unknown",        // 2787
+    "unknown",        // 2788
+    "unknown",        // 2789
+    "unknown",        // 2790
+    "unknown",        // 2791
+    "unknown",        // 2792
+    "unknown",        // 2793
+    "unknown",        // 2794
+    "unknown",        // 2795
+    "unknown",        // 2796
+    "unknown",        // 2797
+    "unknown",        // 2798
+    "unknown",        // 2799
+    "unknown",        // 2800
+    "unknown",        // 2801
+    "unknown",        // 2802
+    "unknown",        // 2803
+    "unknown",        // 2804
+    "unknown",        // 2805
+    "unknown",        // 2806
+    "unknown",        // 2807
+    "unknown",        // 2808
+    "unknown",        // 2809
+    "unknown",        // 2810
+    "unknown",        // 2811
+    "unknown",        // 2812
+    "unknown",        // 2813
+    "unknown",        // 2814
+    "unknown",        // 2815
+    "mcycle",         // 2816
+    "unknown",        // 2817
+    "minstret",       // 2818
+    "mhpmcounter3",   // 2819
+    "mhpmcounter4",   // 2820
+    "mhpmcounter5",   // 2821
+    "mhpmcounter6",   // 2822
+    "mhpmcounter7",   // 2823
+    "mhpmcounter8",   // 2824
+    "mhpmcounter9",   // 2825
+    "mhpmcounter10",  // 2826
+    "mhpmcounter11",  // 2827
+    "mhpmcounter12",  // 2828
+    "mhpmcounter13",  // 2829
+    "mhpmcounter14",  // 2830
+    "mhpmcounter15",  // 2831
+    "mhpmcounter16",  // 2832
+    "mhpmcounter17",  // 2833
+    "mhpmcounter18",  // 2834
+    "mhpmcounter19",  // 2835
+    "mhpmcounter20",  // 2836
+    "mhpmcounter21",  // 2837
+    "mhpmcounter22",  // 2838
+    "mhpmcounter23",  // 2839
+    "mhpmcounter24",  // 2840
+    "mhpmcounter25",  // 2841
+    "mhpmcounter26",  // 2842
+    "mhpmcounter27",  // 2843
+    "mhpmcounter28",  // 2844
+    "mhpmcounter29",  // 2845
+    "mhpmcounter30",  // 2846
+    "mhpmcounter31",  // 2847
+    "unknown",        // 2848
+    "unknown",        // 2849
+    "unknown",        // 2850
+    "unknown",        // 2851
+    "unknown",        // 2852
+    "unknown",        // 2853
+    "unknown",        // 2854
+    "unknown",        // 2855
+    "unknown",        // 2856
+    "unknown",        // 2857
+    "unknown",        // 2858
+    "unknown",        // 2859
+    "unknown",        // 2860
+    "unknown",        // 2861
+    "unknown",        // 2862
+    "unknown",        // 2863
+    "unknown",        // 2864
+    "unknown",        // 2865
+    "unknown",        // 2866
+    "unknown",        // 2867
+    "unknown",        // 2868
+    "unknown",        // 2869
+    "unknown",        // 2870
+    "unknown",        // 2871
+    "unknown",        // 2872
+    "unknown",        // 2873
+    "unknown",        // 2874
+    "unknown",        // 2875
+    "unknown",        // 2876
+    "unknown",        // 2877
+    "unknown",        // 2878
+    "unknown",        // 2879
+    "unknown",        // 2880
+    "unknown",        // 2881
+    "unknown",        // 2882
+    "unknown",        // 2883
+    "unknown",        // 2884
+    "unknown",        // 2885
+    "unknown",        // 2886
+    "unknown",        // 2887
+    "unknown",        // 2888
+    "unknown",        // 2889
+    "unknown",        // 2890
+    "unknown",        // 2891
+    "unknown",        // 2892
+    "unknown",        // 2893
+    "unknown",        // 2894
+    "unknown",        // 2895
+    "unknown",        // 2896
+    "unknown",        // 2897
+    "unknown",        // 2898
+    "unknown",        // 2899
+    "unknown",        // 2900
+    "unknown",        // 2901
+    "unknown",        // 2902
+    "unknown",        // 2903
+    "unknown",        // 2904
+    "unknown",        // 2905
+    "unknown",        // 2906
+    "unknown",        // 2907
+    "unknown",        // 2908
+    "unknown",        // 2909
+    "unknown",        // 2910
+    "unknown",        // 2911
+    "unknown",        // 2912
+    "unknown",        // 2913
+    "unknown",        // 2914
+    "unknown",        // 2915
+    "unknown",        // 2916
+    "unknown",        // 2917
+    "unknown",        // 2918
+    "unknown",        // 2919
+    "unknown",        // 2920
+    "unknown",        // 2921
+    "unknown",        // 2922
+    "unknown",        // 2923
+    "unknown",        // 2924
+    "unknown",        // 2925
+    "unknown",        // 2926
+    "unknown",        // 2927
+    "unknown",        // 2928
+    "unknown",        // 2929
+    "unknown",        // 2930
+    "unknown",        // 2931
+    "unknown",        // 2932
+    "unknown",        // 2933
+    "unknown",        // 2934
+    "unknown",        // 2935
+    "unknown",        // 2936
+    "unknown",        // 2937
+    "unknown",        // 2938
+    "unknown",        // 2939
+    "unknown",        // 2940
+    "unknown",        // 2941
+    "unknown",        // 2942
+    "unknown",        // 2943
+    "mcycleh",        // 2944
+    "unknown",        // 2945
+    "minstreth",      // 2946
+    "mhpmcounter3h",  // 2947
+    "mhpmcounter4h",  // 2948
+    "mhpmcounter5h",  // 2949
+    "mhpmcounter6h",  // 2950
+    "mhpmcounter7h",  // 2951
+    "mhpmcounter8h",  // 2952
+    "mhpmcounter9h",  // 2953
+    "mhpmcounter10h", // 2954
+    "mhpmcounter11h", // 2955
+    "mhpmcounter12h", // 2956
+    "mhpmcounter13h", // 2957
+    "mhpmcounter14h", // 2958
+    "mhpmcounter15h", // 2959
+    "mhpmcounter16h", // 2960
+    "mhpmcounter17h", // 2961
+    "mhpmcounter18h", // 2962
+    "mhpmcounter19h", // 2963
+    "mhpmcounter20h", // 2964
+    "mhpmcounter21h", // 2965
+    "mhpmcounter22h", // 2966
+    "mhpmcounter23h", // 2967
+    "mhpmcounter24h", // 2968
+    "mhpmcounter25h", // 2969
+    "mhpmcounter26h", // 2970
+    "mhpmcounter27h", // 2971
+    "mhpmcounter28h", // 2972
+    "mhpmcounter29h", // 2973
+    "mhpmcounter30h", // 2974
+    "mhpmcounter31h", // 2975
+    "unknown",        // 2976
+    "unknown",        // 2977
+    "unknown",        // 2978
+    "unknown",        // 2979
+    "unknown",        // 2980
+    "unknown",        // 2981
+    "unknown",        // 2982
+    "unknown",        // 2983
+    "unknown",        // 2984
+    "unknown",        // 2985
+    "unknown",        // 2986
+    "unknown",        // 2987
+    "unknown",        // 2988
+    "unknown",        // 2989
+    "unknown",        // 2990
+    "unknown",        // 2991
+    "unknown",        // 2992
+    "unknown",        // 2993
+    "unknown",        // 2994
+    "unknown",        // 2995
+    "unknown",        // 2996
+    "unknown",        // 2997
+    "unknown",        // 2998
+    "unknown",        // 2999
+    "unknown",        // 3000
+    "unknown",        // 3001
+    "unknown",        // 3002
+    "unknown",        // 3003
+    "unknown",        // 3004
+    "unknown",        // 3005
+    "unknown",        // 3006
+    "unknown",        // 3007
+    "unknown",        // 3008
+    "unknown",        // 3009
+    "unknown",        // 3010
+    "unknown",        // 3011
+    "unknown",        // 3012
+    "unknown",        // 3013
+    "unknown",        // 3014
+    "unknown",        // 3015
+    "unknown",        // 3016
+    "unknown",        // 3017
+    "unknown",        // 3018
+    "unknown",        // 3019
+    "unknown",        // 3020
+    "unknown",        // 3021
+    "unknown",        // 3022
+    "unknown",        // 3023
+    "unknown",        // 3024
+    "unknown",        // 3025
+    "unknown",        // 3026
+    "unknown",        // 3027
+    "unknown",        // 3028
+    "unknown",        // 3029
+    "unknown",        // 3030
+    "unknown",        // 3031
+    "unknown",        // 3032
+    "unknown",        // 3033
+    "unknown",        // 3034
+    "unknown",        // 3035
+    "unknown",        // 3036
+    "unknown",        // 3037
+    "unknown",        // 3038
+    "unknown",        // 3039
+    "unknown",        // 3040
+    "unknown",        // 3041
+    "unknown",        // 3042
+    "unknown",        // 3043
+    "unknown",        // 3044
+    "unknown",        // 3045
+    "unknown",        // 3046
+    "unknown",        // 3047
+    "unknown",        // 3048
+    "unknown",        // 3049
+    "unknown",        // 3050
+    "unknown",        // 3051
+    "unknown",        // 3052
+    "unknown",        // 3053
+    "unknown",        // 3054
+    "unknown",        // 3055
+    "unknown",        // 3056
+    "unknown",        // 3057
+    "unknown",        // 3058
+    "unknown",        // 3059
+    "unknown",        // 3060
+    "unknown",        // 3061
+    "unknown",        // 3062
+    "unknown",        // 3063
+    "unknown",        // 3064
+    "unknown",        // 3065
+    "unknown",        // 3066
+    "unknown",        // 3067
+    "unknown",        // 3068
+    "unknown",        // 3069
+    "unknown",        // 3070
+    "unknown",        // 3071
+    "cycle",          // 3072
+    "time",           // 3073
+    "instret",        // 3074
+    "hpmcounter3",    // 3075
+    "hpmcounter4",    // 3076
+    "hpmcounter5",    // 3077
+    "hpmcounter6",    // 3078
+    "hpmcounter7",    // 3079
+    "hpmcounter8",    // 3080
+    "hpmcounter9",    // 3081
+    "hpmcounter10",   // 3082
+    "hpmcounter11",   // 3083
+    "hpmcounter12",   // 3084
+    "hpmcounter13",   // 3085
+    "hpmcounter14",   // 3086
+    "hpmcounter15",   // 3087
+    "hpmcounter16",   // 3088
+    "hpmcounter17",   // 3089
+    "hpmcounter18",   // 3090
+    "hpmcounter19",   // 3091
+    "hpmcounter20",   // 3092
+    "hpmcounter21",   // 3093
+    "hpmcounter22",   // 3094
+    "hpmcounter23",   // 3095
+    "hpmcounter24",   // 3096
+    "hpmcounter25",   // 3097
+    "hpmcounter26",   // 3098
+    "hpmcounter27",   // 3099
+    "hpmcounter28",   // 3100
+    "hpmcounter29",   // 3101
+    "hpmcounter30",   // 3102
+    "hpmcounter31",   // 3103
+    "vl",             // 3104
+    "vtype",          // 3105
+    "vlenb",          // 3106
+    "unknown",        // 3107
+    "unknown",        // 3108
+    "unknown",        // 3109
+    "unknown",        // 3110
+    "unknown",        // 3111
+    "unknown",        // 3112
+    "unknown",        // 3113
+    "unknown",        // 3114
+    "unknown",        // 3115
+    "unknown",        // 3116
+    "unknown",        // 3117
+    "unknown",        // 3118
+    "unknown",        // 3119
+    "unknown",        // 3120
+    "unknown",        // 3121
+    "unknown",        // 3122
+    "unknown",        // 3123
+    "unknown",        // 3124
+    "unknown",        // 3125
+    "unknown",        // 3126
+    "unknown",        // 3127
+    "unknown",        // 3128
+    "unknown",        // 3129
+    "unknown",        // 3130
+    "unknown",        // 3131
+    "unknown",        // 3132
+    "unknown",        // 3133
+    "unknown",        // 3134
+    "unknown",        // 3135
+    "unknown",        // 3136
+    "unknown",        // 3137
+    "unknown",        // 3138
+    "unknown",        // 3139
+    "unknown",        // 3140
+    "unknown",        // 3141
+    "unknown",        // 3142
+    "unknown",        // 3143
+    "unknown",        // 3144
+    "unknown",        // 3145
+    "unknown",        // 3146
+    "unknown",        // 3147
+    "unknown",        // 3148
+    "unknown",        // 3149
+    "unknown",        // 3150
+    "unknown",        // 3151
+    "unknown",        // 3152
+    "unknown",        // 3153
+    "unknown",        // 3154
+    "unknown",        // 3155
+    "unknown",        // 3156
+    "unknown",        // 3157
+    "unknown",        // 3158
+    "unknown",        // 3159
+    "unknown",        // 3160
+    "unknown",        // 3161
+    "unknown",        // 3162
+    "unknown",        // 3163
+    "unknown",        // 3164
+    "unknown",        // 3165
+    "unknown",        // 3166
+    "unknown",        // 3167
+    "unknown",        // 3168
+    "unknown",        // 3169
+    "unknown",        // 3170
+    "unknown",        // 3171
+    "unknown",        // 3172
+    "unknown",        // 3173
+    "unknown",        // 3174
+    "unknown",        // 3175
+    "unknown",        // 3176
+    "unknown",        // 3177
+    "unknown",        // 3178
+    "unknown",        // 3179
+    "unknown",        // 3180
+    "unknown",        // 3181
+    "unknown",        // 3182
+    "unknown",        // 3183
+    "unknown",        // 3184
+    "unknown",        // 3185
+    "unknown",        // 3186
+    "unknown",        // 3187
+    "unknown",        // 3188
+    "unknown",        // 3189
+    "unknown",        // 3190
+    "unknown",        // 3191
+    "unknown",        // 3192
+    "unknown",        // 3193
+    "unknown",        // 3194
+    "unknown",        // 3195
+    "unknown",        // 3196
+    "unknown",        // 3197
+    "unknown",        // 3198
+    "unknown",        // 3199
+    "cycleh",         // 3200
+    "timeh",          // 3201
+    "instreth",       // 3202
+    "hpmcounter3h",   // 3203
+    "hpmcounter4h",   // 3204
+    "hpmcounter5h",   // 3205
+    "hpmcounter6h",   // 3206
+    "hpmcounter7h",   // 3207
+    "hpmcounter8h",   // 3208
+    "hpmcounter9h",   // 3209
+    "hpmcounter10h",  // 3210
+    "hpmcounter11h",  // 3211
+    "hpmcounter12h",  // 3212
+    "hpmcounter13h",  // 3213
+    "hpmcounter14h",  // 3214
+    "hpmcounter15h",  // 3215
+    "hpmcounter16h",  // 3216
+    "hpmcounter17h",  // 3217
+    "hpmcounter18h",  // 3218
+    "hpmcounter19h",  // 3219
+    "hpmcounter20h",  // 3220
+    "hpmcounter21h",  // 3221
+    "hpmcounter22h",  // 3222
+    "hpmcounter23h",  // 3223
+    "hpmcounter24h",  // 3224
+    "hpmcounter25h",  // 3225
+    "hpmcounter26h",  // 3226
+    "hpmcounter27h",  // 3227
+    "hpmcounter28h",  // 3228
+    "hpmcounter29h",  // 3229
+    "hpmcounter30h",  // 3230
+    "hpmcounter31h",  // 3231
+    "unknown",        // 3232
+    "unknown",        // 3233
+    "unknown",        // 3234
+    "unknown",        // 3235
+    "unknown",        // 3236
+    "unknown",        // 3237
+    "unknown",        // 3238
+    "unknown",        // 3239
+    "unknown",        // 3240
+    "unknown",        // 3241
+    "unknown",        // 3242
+    "unknown",        // 3243
+    "unknown",        // 3244
+    "unknown",        // 3245
+    "unknown",        // 3246
+    "unknown",        // 3247
+    "unknown",        // 3248
+    "unknown",        // 3249
+    "unknown",        // 3250
+    "unknown",        // 3251
+    "unknown",        // 3252
+    "unknown",        // 3253
+    "unknown",        // 3254
+    "unknown",        // 3255
+    "unknown",        // 3256
+    "unknown",        // 3257
+    "unknown",        // 3258
+    "unknown",        // 3259
+    "unknown",        // 3260
+    "unknown",        // 3261
+    "unknown",        // 3262
+    "unknown",        // 3263
+    "unknown",        // 3264
+    "unknown",        // 3265
+    "unknown",        // 3266
+    "unknown",        // 3267
+    "unknown",        // 3268
+    "unknown",        // 3269
+    "unknown",        // 3270
+    "unknown",        // 3271
+    "unknown",        // 3272
+    "unknown",        // 3273
+    "unknown",        // 3274
+    "unknown",        // 3275
+    "unknown",        // 3276
+    "unknown",        // 3277
+    "unknown",        // 3278
+    "unknown",        // 3279
+    "unknown",        // 3280
+    "unknown",        // 3281
+    "unknown",        // 3282
+    "unknown",        // 3283
+    "unknown",        // 3284
+    "unknown",        // 3285
+    "unknown",        // 3286
+    "unknown",        // 3287
+    "unknown",        // 3288
+    "unknown",        // 3289
+    "unknown",        // 3290
+    "unknown",        // 3291
+    "unknown",        // 3292
+    "unknown",        // 3293
+    "unknown",        // 3294
+    "unknown",        // 3295
+    "unknown",        // 3296
+    "unknown",        // 3297
+    "unknown",        // 3298
+    "unknown",        // 3299
+    "unknown",        // 3300
+    "unknown",        // 3301
+    "unknown",        // 3302
+    "unknown",        // 3303
+    "unknown",        // 3304
+    "unknown",        // 3305
+    "unknown",        // 3306
+    "unknown",        // 3307
+    "unknown",        // 3308
+    "unknown",        // 3309
+    "unknown",        // 3310
+    "unknown",        // 3311
+    "unknown",        // 3312
+    "unknown",        // 3313
+    "unknown",        // 3314
+    "unknown",        // 3315
+    "unknown",        // 3316
+    "unknown",        // 3317
+    "unknown",        // 3318
+    "unknown",        // 3319
+    "unknown",        // 3320
+    "unknown",        // 3321
+    "unknown",        // 3322
+    "unknown",        // 3323
+    "unknown",        // 3324
+    "unknown",        // 3325
+    "unknown",        // 3326
+    "unknown",        // 3327
+    "unknown",        // 3328
+    "unknown",        // 3329
+    "unknown",        // 3330
+    "unknown",        // 3331
+    "unknown",        // 3332
+    "unknown",        // 3333
+    "unknown",        // 3334
+    "unknown",        // 3335
+    "unknown",        // 3336
+    "unknown",        // 3337
+    "unknown",        // 3338
+    "unknown",        // 3339
+    "unknown",        // 3340
+    "unknown",        // 3341
+    "unknown",        // 3342
+    "unknown",        // 3343
+    "unknown",        // 3344
+    "unknown",        // 3345
+    "unknown",        // 3346
+    "unknown",        // 3347
+    "unknown",        // 3348
+    "unknown",        // 3349
+    "unknown",        // 3350
+    "unknown",        // 3351
+    "unknown",        // 3352
+    "unknown",        // 3353
+    "unknown",        // 3354
+    "unknown",        // 3355
+    "unknown",        // 3356
+    "unknown",        // 3357
+    "unknown",        // 3358
+    "unknown",        // 3359
+    "unknown",        // 3360
+    "unknown",        // 3361
+    "unknown",        // 3362
+    "unknown",        // 3363
+    "unknown",        // 3364
+    "unknown",        // 3365
+    "unknown",        // 3366
+    "unknown",        // 3367
+    "unknown",        // 3368
+    "unknown",        // 3369
+    "unknown",        // 3370
+    "unknown",        // 3371
+    "unknown",        // 3372
+    "unknown",        // 3373
+    "unknown",        // 3374
+    "unknown",        // 3375
+    "unknown",        // 3376
+    "unknown",        // 3377
+    "unknown",        // 3378
+    "unknown",        // 3379
+    "unknown",        // 3380
+    "unknown",        // 3381
+    "unknown",        // 3382
+    "unknown",        // 3383
+    "unknown",        // 3384
+    "unknown",        // 3385
+    "unknown",        // 3386
+    "unknown",        // 3387
+    "unknown",        // 3388
+    "unknown",        // 3389
+    "unknown",        // 3390
+    "unknown",        // 3391
+    "unknown",        // 3392
+    "unknown",        // 3393
+    "unknown",        // 3394
+    "unknown",        // 3395
+    "unknown",        // 3396
+    "unknown",        // 3397
+    "unknown",        // 3398
+    "unknown",        // 3399
+    "unknown",        // 3400
+    "unknown",        // 3401
+    "unknown",        // 3402
+    "unknown",        // 3403
+    "unknown",        // 3404
+    "unknown",        // 3405
+    "unknown",        // 3406
+    "unknown",        // 3407
+    "unknown",        // 3408
+    "unknown",        // 3409
+    "unknown",        // 3410
+    "unknown",        // 3411
+    "unknown",        // 3412
+    "unknown",        // 3413
+    "unknown",        // 3414
+    "unknown",        // 3415
+    "unknown",        // 3416
+    "unknown",        // 3417
+    "unknown",        // 3418
+    "unknown",        // 3419
+    "unknown",        // 3420
+    "unknown",        // 3421
+    "unknown",        // 3422
+    "unknown",        // 3423
+    "unknown",        // 3424
+    "unknown",        // 3425
+    "unknown",        // 3426
+    "unknown",        // 3427
+    "unknown",        // 3428
+    "unknown",        // 3429
+    "unknown",        // 3430
+    "unknown",        // 3431
+    "unknown",        // 3432
+    "unknown",        // 3433
+    "unknown",        // 3434
+    "unknown",        // 3435
+    "unknown",        // 3436
+    "unknown",        // 3437
+    "unknown",        // 3438
+    "unknown",        // 3439
+    "unknown",        // 3440
+    "unknown",        // 3441
+    "unknown",        // 3442
+    "unknown",        // 3443
+    "unknown",        // 3444
+    "unknown",        // 3445
+    "unknown",        // 3446
+    "unknown",        // 3447
+    "unknown",        // 3448
+    "unknown",        // 3449
+    "unknown",        // 3450
+    "unknown",        // 3451
+    "unknown",        // 3452
+    "unknown",        // 3453
+    "unknown",        // 3454
+    "unknown",        // 3455
+    "unknown",        // 3456
+    "unknown",        // 3457
+    "unknown",        // 3458
+    "unknown",        // 3459
+    "unknown",        // 3460
+    "unknown",        // 3461
+    "unknown",        // 3462
+    "unknown",        // 3463
+    "unknown",        // 3464
+    "unknown",        // 3465
+    "unknown",        // 3466
+    "unknown",        // 3467
+    "unknown",        // 3468
+    "unknown",        // 3469
+    "unknown",        // 3470
+    "unknown",        // 3471
+    "unknown",        // 3472
+    "unknown",        // 3473
+    "unknown",        // 3474
+    "unknown",        // 3475
+    "unknown",        // 3476
+    "unknown",        // 3477
+    "unknown",        // 3478
+    "unknown",        // 3479
+    "unknown",        // 3480
+    "unknown",        // 3481
+    "unknown",        // 3482
+    "unknown",        // 3483
+    "unknown",        // 3484
+    "unknown",        // 3485
+    "unknown",        // 3486
+    "unknown",        // 3487
+    "scountovf",      // 3488
+    "unknown",        // 3489
+    "unknown",        // 3490
+    "unknown",        // 3491
+    "unknown",        // 3492
+    "unknown",        // 3493
+    "unknown",        // 3494
+    "unknown",        // 3495
+    "unknown",        // 3496
+    "unknown",        // 3497
+    "unknown",        // 3498
+    "unknown",        // 3499
+    "unknown",        // 3500
+    "unknown",        // 3501
+    "unknown",        // 3502
+    "unknown",        // 3503
+    "stopi",          // 3504
+    "unknown",        // 3505
+    "unknown",        // 3506
+    "unknown",        // 3507
+    "unknown",        // 3508
+    "unknown",        // 3509
+    "unknown",        // 3510
+    "unknown",        // 3511
+    "unknown",        // 3512
+    "unknown",        // 3513
+    "unknown",        // 3514
+    "unknown",        // 3515
+    "unknown",        // 3516
+    "unknown",        // 3517
+    "unknown",        // 3518
+    "unknown",        // 3519
+    "unknown",        // 3520
+    "unknown",        // 3521
+    "unknown",        // 3522
+    "unknown",        // 3523
+    "unknown",        // 3524
+    "unknown",        // 3525
+    "unknown",        // 3526
+    "unknown",        // 3527
+    "unknown",        // 3528
+    "unknown",        // 3529
+    "unknown",        // 3530
+    "unknown",        // 3531
+    "unknown",        // 3532
+    "unknown",        // 3533
+    "unknown",        // 3534
+    "unknown",        // 3535
+    "unknown",        // 3536
+    "unknown",        // 3537
+    "unknown",        // 3538
+    "unknown",        // 3539
+    "unknown",        // 3540
+    "unknown",        // 3541
+    "unknown",        // 3542
+    "unknown",        // 3543
+    "unknown",        // 3544
+    "unknown",        // 3545
+    "unknown",        // 3546
+    "unknown",        // 3547
+    "unknown",        // 3548
+    "unknown",        // 3549
+    "unknown",        // 3550
+    "unknown",        // 3551
+    "unknown",        // 3552
+    "unknown",        // 3553
+    "unknown",        // 3554
+    "unknown",        // 3555
+    "unknown",        // 3556
+    "unknown",        // 3557
+    "unknown",        // 3558
+    "unknown",        // 3559
+    "unknown",        // 3560
+    "unknown",        // 3561
+    "unknown",        // 3562
+    "unknown",        // 3563
+    "unknown",        // 3564
+    "unknown",        // 3565
+    "unknown",        // 3566
+    "unknown",        // 3567
+    "unknown",        // 3568
+    "unknown",        // 3569
+    "unknown",        // 3570
+    "unknown",        // 3571
+    "unknown",        // 3572
+    "unknown",        // 3573
+    "unknown",        // 3574
+    "unknown",        // 3575
+    "unknown",        // 3576
+    "unknown",        // 3577
+    "unknown",        // 3578
+    "unknown",        // 3579
+    "unknown",        // 3580
+    "unknown",        // 3581
+    "unknown",        // 3582
+    "unknown",        // 3583
+    "unknown",        // 3584
+    "unknown",        // 3585
+    "unknown",        // 3586
+    "unknown",        // 3587
+    "unknown",        // 3588
+    "unknown",        // 3589
+    "unknown",        // 3590
+    "unknown",        // 3591
+    "unknown",        // 3592
+    "unknown",        // 3593
+    "unknown",        // 3594
+    "unknown",        // 3595
+    "unknown",        // 3596
+    "unknown",        // 3597
+    "unknown",        // 3598
+    "unknown",        // 3599
+    "unknown",        // 3600
+    "unknown",        // 3601
+    "hgeip",          // 3602
+    "unknown",        // 3603
+    "unknown",        // 3604
+    "unknown",        // 3605
+    "unknown",        // 3606
+    "unknown",        // 3607
+    "unknown",        // 3608
+    "unknown",        // 3609
+    "unknown",        // 3610
+    "unknown",        // 3611
+    "unknown",        // 3612
+    "unknown",        // 3613
+    "unknown",        // 3614
+    "unknown",        // 3615
+    "unknown",        // 3616
+    "unknown",        // 3617
+    "unknown",        // 3618
+    "unknown",        // 3619
+    "unknown",        // 3620
+    "unknown",        // 3621
+    "unknown",        // 3622
+    "unknown",        // 3623
+    "unknown",        // 3624
+    "unknown",        // 3625
+    "unknown",        // 3626
+    "unknown",        // 3627
+    "unknown",        // 3628
+    "unknown",        // 3629
+    "unknown",        // 3630
+    "unknown",        // 3631
+    "unknown",        // 3632
+    "unknown",        // 3633
+    "unknown",        // 3634
+    "unknown",        // 3635
+    "unknown",        // 3636
+    "unknown",        // 3637
+    "unknown",        // 3638
+    "unknown",        // 3639
+    "unknown",        // 3640
+    "unknown",        // 3641
+    "unknown",        // 3642
+    "unknown",        // 3643
+    "unknown",        // 3644
+    "unknown",        // 3645
+    "unknown",        // 3646
+    "unknown",        // 3647
+    "unknown",        // 3648
+    "unknown",        // 3649
+    "unknown",        // 3650
+    "unknown",        // 3651
+    "unknown",        // 3652
+    "unknown",        // 3653
+    "unknown",        // 3654
+    "unknown",        // 3655
+    "unknown",        // 3656
+    "unknown",        // 3657
+    "unknown",        // 3658
+    "unknown",        // 3659
+    "unknown",        // 3660
+    "unknown",        // 3661
+    "unknown",        // 3662
+    "unknown",        // 3663
+    "unknown",        // 3664
+    "unknown",        // 3665
+    "unknown",        // 3666
+    "unknown",        // 3667
+    "unknown",        // 3668
+    "unknown",        // 3669
+    "unknown",        // 3670
+    "unknown",        // 3671
+    "unknown",        // 3672
+    "unknown",        // 3673
+    "unknown",        // 3674
+    "unknown",        // 3675
+    "unknown",        // 3676
+    "unknown",        // 3677
+    "unknown",        // 3678
+    "unknown",        // 3679
+    "unknown",        // 3680
+    "unknown",        // 3681
+    "unknown",        // 3682
+    "unknown",        // 3683
+    "unknown",        // 3684
+    "unknown",        // 3685
+    "unknown",        // 3686
+    "unknown",        // 3687
+    "unknown",        // 3688
+    "unknown",        // 3689
+    "unknown",        // 3690
+    "unknown",        // 3691
+    "unknown",        // 3692
+    "unknown",        // 3693
+    "unknown",        // 3694
+    "unknown",        // 3695
+    "unknown",        // 3696
+    "unknown",        // 3697
+    "unknown",        // 3698
+    "unknown",        // 3699
+    "unknown",        // 3700
+    "unknown",        // 3701
+    "unknown",        // 3702
+    "unknown",        // 3703
+    "unknown",        // 3704
+    "unknown",        // 3705
+    "unknown",        // 3706
+    "unknown",        // 3707
+    "unknown",        // 3708
+    "unknown",        // 3709
+    "unknown",        // 3710
+    "unknown",        // 3711
+    "unknown",        // 3712
+    "unknown",        // 3713
+    "unknown",        // 3714
+    "unknown",        // 3715
+    "unknown",        // 3716
+    "unknown",        // 3717
+    "unknown",        // 3718
+    "unknown",        // 3719
+    "unknown",        // 3720
+    "unknown",        // 3721
+    "unknown",        // 3722
+    "unknown",        // 3723
+    "unknown",        // 3724
+    "unknown",        // 3725
+    "unknown",        // 3726
+    "unknown",        // 3727
+    "unknown",        // 3728
+    "unknown",        // 3729
+    "unknown",        // 3730
+    "unknown",        // 3731
+    "unknown",        // 3732
+    "unknown",        // 3733
+    "unknown",        // 3734
+    "unknown",        // 3735
+    "unknown",        // 3736
+    "unknown",        // 3737
+    "unknown",        // 3738
+    "unknown",        // 3739
+    "unknown",        // 3740
+    "unknown",        // 3741
+    "unknown",        // 3742
+    "unknown",        // 3743
+    "unknown",        // 3744
+    "unknown",        // 3745
+    "unknown",        // 3746
+    "unknown",        // 3747
+    "unknown",        // 3748
+    "unknown",        // 3749
+    "unknown",        // 3750
+    "unknown",        // 3751
+    "unknown",        // 3752
+    "unknown",        // 3753
+    "unknown",        // 3754
+    "unknown",        // 3755
+    "unknown",        // 3756
+    "unknown",        // 3757
+    "unknown",        // 3758
+    "unknown",        // 3759
+    "vstopi",         // 3760
+    "unknown",        // 3761
+    "unknown",        // 3762
+    "unknown",        // 3763
+    "unknown",        // 3764
+    "unknown",        // 3765
+    "unknown",        // 3766
+    "unknown",        // 3767
+    "unknown",        // 3768
+    "unknown",        // 3769
+    "unknown",        // 3770
+    "unknown",        // 3771
+    "unknown",        // 3772
+    "unknown",        // 3773
+    "unknown",        // 3774
+    "unknown",        // 3775
+    "unknown",        // 3776
+    "unknown",        // 3777
+    "unknown",        // 3778
+    "unknown",        // 3779
+    "unknown",        // 3780
+    "unknown",        // 3781
+    "unknown",        // 3782
+    "unknown",        // 3783
+    "unknown",        // 3784
+    "unknown",        // 3785
+    "unknown",        // 3786
+    "unknown",        // 3787
+    "unknown",        // 3788
+    "unknown",        // 3789
+    "unknown",        // 3790
+    "unknown",        // 3791
+    "unknown",        // 3792
+    "unknown",        // 3793
+    "unknown",        // 3794
+    "unknown",        // 3795
+    "unknown",        // 3796
+    "unknown",        // 3797
+    "unknown",        // 3798
+    "unknown",        // 3799
+    "unknown",        // 3800
+    "unknown",        // 3801
+    "unknown",        // 3802
+    "unknown",        // 3803
+    "unknown",        // 3804
+    "unknown",        // 3805
+    "unknown",        // 3806
+    "unknown",        // 3807
+    "unknown",        // 3808
+    "unknown",        // 3809
+    "unknown",        // 3810
+    "unknown",        // 3811
+    "unknown",        // 3812
+    "unknown",        // 3813
+    "unknown",        // 3814
+    "unknown",        // 3815
+    "unknown",        // 3816
+    "unknown",        // 3817
+    "unknown",        // 3818
+    "unknown",        // 3819
+    "unknown",        // 3820
+    "unknown",        // 3821
+    "unknown",        // 3822
+    "unknown",        // 3823
+    "unknown",        // 3824
+    "unknown",        // 3825
+    "unknown",        // 3826
+    "unknown",        // 3827
+    "unknown",        // 3828
+    "unknown",        // 3829
+    "unknown",        // 3830
+    "unknown",        // 3831
+    "unknown",        // 3832
+    "unknown",        // 3833
+    "unknown",        // 3834
+    "unknown",        // 3835
+    "unknown",        // 3836
+    "unknown",        // 3837
+    "unknown",        // 3838
+    "unknown",        // 3839
+    "unknown",        // 3840
+    "unknown",        // 3841
+    "unknown",        // 3842
+    "unknown",        // 3843
+    "unknown",        // 3844
+    "unknown",        // 3845
+    "unknown",        // 3846
+    "unknown",        // 3847
+    "unknown",        // 3848
+    "unknown",        // 3849
+    "unknown",        // 3850
+    "unknown",        // 3851
+    "unknown",        // 3852
+    "unknown",        // 3853
+    "unknown",        // 3854
+    "unknown",        // 3855
+    "unknown",        // 3856
+    "mvendorid",      // 3857
+    "marchid",        // 3858
+    "mimpid",         // 3859
+    "mhartid",        // 3860
+    "mconfigptr",     // 3861
+    "unknown",        // 3862
+    "unknown",        // 3863
+    "unknown",        // 3864
+    "unknown",        // 3865
+    "unknown",        // 3866
+    "unknown",        // 3867
+    "unknown",        // 3868
+    "unknown",        // 3869
+    "unknown",        // 3870
+    "unknown",        // 3871
+    "unknown",        // 3872
+    "unknown",        // 3873
+    "unknown",        // 3874
+    "unknown",        // 3875
+    "unknown",        // 3876
+    "unknown",        // 3877
+    "unknown",        // 3878
+    "unknown",        // 3879
+    "unknown",        // 3880
+    "unknown",        // 3881
+    "unknown",        // 3882
+    "unknown",        // 3883
+    "unknown",        // 3884
+    "unknown",        // 3885
+    "unknown",        // 3886
+    "unknown",        // 3887
+    "unknown",        // 3888
+    "unknown",        // 3889
+    "unknown",        // 3890
+    "unknown",        // 3891
+    "unknown",        // 3892
+    "unknown",        // 3893
+    "unknown",        // 3894
+    "unknown",        // 3895
+    "unknown",        // 3896
+    "unknown",        // 3897
+    "unknown",        // 3898
+    "unknown",        // 3899
+    "unknown",        // 3900
+    "unknown",        // 3901
+    "unknown",        // 3902
+    "unknown",        // 3903
+    "unknown",        // 3904
+    "unknown",        // 3905
+    "unknown",        // 3906
+    "unknown",        // 3907
+    "unknown",        // 3908
+    "unknown",        // 3909
+    "unknown",        // 3910
+    "unknown",        // 3911
+    "unknown",        // 3912
+    "unknown",        // 3913
+    "unknown",        // 3914
+    "unknown",        // 3915
+    "unknown",        // 3916
+    "unknown",        // 3917
+    "unknown",        // 3918
+    "unknown",        // 3919
+    "unknown",        // 3920
+    "unknown",        // 3921
+    "unknown",        // 3922
+    "unknown",        // 3923
+    "unknown",        // 3924
+    "unknown",        // 3925
+    "unknown",        // 3926
+    "unknown",        // 3927
+    "unknown",        // 3928
+    "unknown",        // 3929
+    "unknown",        // 3930
+    "unknown",        // 3931
+    "unknown",        // 3932
+    "unknown",        // 3933
+    "unknown",        // 3934
+    "unknown",        // 3935
+    "unknown",        // 3936
+    "unknown",        // 3937
+    "unknown",        // 3938
+    "unknown",        // 3939
+    "unknown",        // 3940
+    "unknown",        // 3941
+    "unknown",        // 3942
+    "unknown",        // 3943
+    "unknown",        // 3944
+    "unknown",        // 3945
+    "unknown",        // 3946
+    "unknown",        // 3947
+    "unknown",        // 3948
+    "unknown",        // 3949
+    "unknown",        // 3950
+    "unknown",        // 3951
+    "unknown",        // 3952
+    "unknown",        // 3953
+    "unknown",        // 3954
+    "unknown",        // 3955
+    "unknown",        // 3956
+    "unknown",        // 3957
+    "unknown",        // 3958
+    "unknown",        // 3959
+    "unknown",        // 3960
+    "unknown",        // 3961
+    "unknown",        // 3962
+    "unknown",        // 3963
+    "unknown",        // 3964
+    "unknown",        // 3965
+    "unknown",        // 3966
+    "unknown",        // 3967
+    "unknown",        // 3968
+    "unknown",        // 3969
+    "unknown",        // 3970
+    "unknown",        // 3971
+    "unknown",        // 3972
+    "unknown",        // 3973
+    "unknown",        // 3974
+    "unknown",        // 3975
+    "unknown",        // 3976
+    "unknown",        // 3977
+    "unknown",        // 3978
+    "unknown",        // 3979
+    "unknown",        // 3980
+    "unknown",        // 3981
+    "unknown",        // 3982
+    "unknown",        // 3983
+    "unknown",        // 3984
+    "unknown",        // 3985
+    "unknown",        // 3986
+    "unknown",        // 3987
+    "unknown",        // 3988
+    "unknown",        // 3989
+    "unknown",        // 3990
+    "unknown",        // 3991
+    "unknown",        // 3992
+    "unknown",        // 3993
+    "unknown",        // 3994
+    "unknown",        // 3995
+    "unknown",        // 3996
+    "unknown",        // 3997
+    "unknown",        // 3998
+    "unknown",        // 3999
+    "unknown",        // 4000
+    "unknown",        // 4001
+    "unknown",        // 4002
+    "unknown",        // 4003
+    "unknown",        // 4004
+    "unknown",        // 4005
+    "unknown",        // 4006
+    "unknown",        // 4007
+    "unknown",        // 4008
+    "unknown",        // 4009
+    "unknown",        // 4010
+    "unknown",        // 4011
+    "unknown",        // 4012
+    "unknown",        // 4013
+    "unknown",        // 4014
+    "unknown",        // 4015
+    "mtopi",          // 4016
+    "unknown",        // 4017
+    "unknown",        // 4018
+    "unknown",        // 4019
+    "unknown",        // 4020
+    "unknown",        // 4021
+    "unknown",        // 4022
+    "unknown",        // 4023
+    "unknown",        // 4024
+    "unknown",        // 4025
+    "unknown",        // 4026
+    "unknown",        // 4027
+    "unknown",        // 4028
+    "unknown",        // 4029
+    "unknown",        // 4030
+    "unknown",        // 4031
+    "unknown",        // 4032
+    "unknown",        // 4033
+    "unknown",        // 4034
+    "unknown",        // 4035
+    "unknown",        // 4036
+    "unknown",        // 4037
+    "unknown",        // 4038
+    "unknown",        // 4039
+    "unknown",        // 4040
+    "unknown",        // 4041
+    "unknown",        // 4042
+    "unknown",        // 4043
+    "unknown",        // 4044
+    "unknown",        // 4045
+    "unknown",        // 4046
+    "unknown",        // 4047
+    "unknown",        // 4048
+    "unknown",        // 4049
+    "unknown",        // 4050
+    "unknown",        // 4051
+    "unknown",        // 4052
+    "unknown",        // 4053
+    "unknown",        // 4054
+    "unknown",        // 4055
+    "unknown",        // 4056
+    "unknown",        // 4057
+    "unknown",        // 4058
+    "unknown",        // 4059
+    "unknown",        // 4060
+    "unknown",        // 4061
+    "unknown",        // 4062
+    "unknown",        // 4063
+    "unknown",        // 4064
+    "unknown",        // 4065
+    "unknown",        // 4066
+    "unknown",        // 4067
+    "unknown",        // 4068
+    "unknown",        // 4069
+    "unknown",        // 4070
+    "unknown",        // 4071
+    "unknown",        // 4072
+    "unknown",        // 4073
+    "unknown",        // 4074
+    "unknown",        // 4075
+    "unknown",        // 4076
+    "unknown",        // 4077
+    "unknown",        // 4078
+    "unknown",        // 4079
+    "unknown",        // 4080
+    "unknown",        // 4081
+    "unknown",        // 4082
+    "unknown",        // 4083
+    "unknown",        // 4084
+    "unknown",        // 4085
+    "unknown",        // 4086
+    "unknown",        // 4087
+    "unknown",        // 4088
+    "unknown",        // 4089
+    "unknown",        // 4090
+    "unknown",        // 4091
+    "unknown",        // 4092
+    "unknown",        // 4093
+    "unknown",        // 4094
+    "unknown",        // 4095
 };
 char const* const get_csr_name(unsigned i) { return csr_names[i]; }
 
-}
-}
+} // namespace debugger
+} // namespace iss
diff --git a/src/iss/debugger/riscv_target_adapter.h b/src/iss/debugger/riscv_target_adapter.h
index 83e9fcf..588c0c6 100644
--- a/src/iss/debugger/riscv_target_adapter.h
+++ b/src/iss/debugger/riscv_target_adapter.h
@@ -39,8 +39,6 @@
 #include <iss/iss.h>
 
 #include <array>
-#include <iostream>
-#include <fstream>
 #include <memory>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -109,7 +107,7 @@ public:
     status process_query(unsigned int& mask, const rp_thread_ref& arg, rp_thread_info& info) override;
 
     status thread_list_query(int first, const rp_thread_ref& arg, std::vector<rp_thread_ref>& result, size_t max_num, size_t& num,
-            bool& done) override;
+                             bool& done) override;
 
     status current_thread_query(rp_thread_ref& thread) override;
 
@@ -140,15 +138,11 @@ protected:
     rp_thread_ref thread_idx;
 };
 
-template <typename ARCH>
-typename std::enable_if<iss::arch::traits<ARCH>::FLEN!=0, unsigned>::type get_f0_offset() {
+template <typename ARCH> typename std::enable_if<iss::arch::traits<ARCH>::FLEN != 0, unsigned>::type get_f0_offset() {
     return iss::arch::traits<ARCH>::F0;
 }
 
-template <typename ARCH>
-typename std::enable_if<iss::arch::traits<ARCH>::FLEN==0, unsigned>::type get_f0_offset() {
-    return 0;
-}
+template <typename ARCH> typename std::enable_if<iss::arch::traits<ARCH>::FLEN == 0, unsigned>::type get_f0_offset() { return 0; }
 
 template <typename ARCH> status riscv_target_adapter<ARCH>::set_gen_thread(rp_thread_ref& thread) {
     thread_idx = thread;
@@ -197,14 +191,14 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::read_registers(std::
     auto start_reg = arch::traits<ARCH>::X0;
     for(size_t i = 0; i < 33; ++i) {
         if(i < arch::traits<ARCH>::RFS || i == arch::traits<ARCH>::PC) {
-            auto reg_no = i<32? start_reg + i: arch::traits<ARCH>::PC;
+            auto reg_no = i < 32 ? start_reg + i : arch::traits<ARCH>::PC;
             unsigned offset = traits<ARCH>::reg_byte_offsets[reg_no];
-            for(size_t j = 0; j < arch::traits<ARCH>::XLEN/8; ++j) {
+            for(size_t j = 0; j < arch::traits<ARCH>::XLEN / 8; ++j) {
                 data.push_back(*(reg_base + offset + j));
                 avail.push_back(0xff);
             }
         } else {
-            for(size_t j = 0; j < arch::traits<ARCH>::XLEN/8; ++j) {
+            for(size_t j = 0; j < arch::traits<ARCH>::XLEN / 8; ++j) {
                 data.push_back(0);
                 avail.push_back(0);
             }
@@ -229,15 +223,15 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
     auto start_reg = arch::traits<ARCH>::X0;
     auto* reg_base = core->get_regs_base_ptr();
     auto iter = data.data();
-    auto iter_end = data.data()+data.size();
+    auto iter_end = data.data() + data.size();
     for(size_t i = 0; i < 33 && iter < iter_end; ++i) {
         auto reg_width = arch::traits<ARCH>::XLEN / 8;
         if(i < arch::traits<ARCH>::RFS) {
             auto offset = traits<ARCH>::reg_byte_offsets[start_reg + i];
-            std::copy(iter, iter + reg_width, reg_base+offset);
+            std::copy(iter, iter + reg_width, reg_base + offset);
         } else if(i == 32) {
             auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
-            std::copy(iter, iter + reg_width, reg_base+offset);
+            std::copy(iter, iter + reg_width, reg_base + offset);
         }
         iter += reg_width;
     }
@@ -246,7 +240,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
         auto reg_width = arch::traits<ARCH>::FLEN / 8;
         for(size_t i = 0; i < 32 && iter < iter_end; ++i) {
             unsigned offset = traits<ARCH>::reg_byte_offsets[fstart_reg + i];
-            std::copy(iter, iter + reg_width, reg_base+offset);
+            std::copy(iter, iter + reg_width, reg_base + offset);
             iter += reg_width;
         }
     }
@@ -255,7 +249,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::write_registers(cons
 
 template <typename ARCH>
 status riscv_target_adapter<ARCH>::read_single_register(unsigned int reg_no, std::vector<uint8_t>& data, std::vector<uint8_t>& avail) {
-    if(reg_no <csr_offset) {
+    if(reg_no < csr_offset) {
         // auto reg_size = arch::traits<ARCH>::reg_bit_width(static_cast<typename
         // arch::traits<ARCH>::reg_e>(reg_no))/8;
         auto* reg_base = core->get_regs_base_ptr();
@@ -349,7 +343,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::add_break(break_type
         auto eaddr = map_addr({iss::access_type::FETCH, iss::address_type::PHYSICAL, 0, addr + length});
         target_adapter_base::bp_lut.addEntry(++target_adapter_base::bp_count, saddr.val, eaddr.val - saddr.val);
         CPPLOG(TRACE) << "Adding breakpoint with handle " << target_adapter_base::bp_count << " for addr 0x" << std::hex << saddr.val
-                << std::dec;
+                      << std::dec;
         CPPLOG(TRACE) << "Now having " << target_adapter_base::bp_lut.size() << " breakpoints";
         return Ok;
     }
@@ -379,7 +373,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::remove_break(break_t
 
 template <typename ARCH>
 status riscv_target_adapter<ARCH>::resume_from_addr(bool step, int sig, uint64_t addr, rp_thread_ref thread,
-        std::function<void(unsigned)> stop_callback) {
+                                                    std::function<void(unsigned)> stop_callback) {
     auto* reg_base = core->get_regs_base_ptr();
     auto reg_width = arch::traits<ARCH>::reg_bit_widths[arch::traits<ARCH>::PC] / 8;
     auto offset = traits<ARCH>::reg_byte_offsets[arch::traits<ARCH>::PC];
@@ -398,17 +392,20 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
             oss << "  <architectureriscv:rv64</architecture>\n";
         oss << "  <feature name=\"org.gnu.gdb.riscv.cpu\">\n";
         auto reg_base_num = iss::arch::traits<ARCH>::X0;
-        for(auto i = 0U; i<iss::arch::traits<ARCH>::RFS; ++i) {
-            oss << "    <reg name=\"x" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i] << "\" type=\"int\" regnum=\"" << i << "\"/>\n";
+        for(auto i = 0U; i < iss::arch::traits<ARCH>::RFS; ++i) {
+            oss << "    <reg name=\"x" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i]
+                << "\" type=\"int\" regnum=\"" << i << "\"/>\n";
         }
-        oss << "    <reg name=\"pc\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[iss::arch::traits<ARCH>::PC] << "\" type=\"code_ptr\" regnum=\"" << 32U << "\"/>\n";
+        oss << "    <reg name=\"pc\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[iss::arch::traits<ARCH>::PC]
+            << "\" type=\"code_ptr\" regnum=\"" << 32U << "\"/>\n";
         oss << "  </feature>\n";
         if(iss::arch::traits<ARCH>::FLEN > 0) {
             oss << "  <feature name=\"org.gnu.gdb.riscv.fpu\">\n";
-            auto reg_base_num =  get_f0_offset<ARCH>();
-            auto type = iss::arch::traits<ARCH>::FLEN==32?"ieee_single":"riscv_double";
-            for(auto i = 0U; i<32; ++i) {
-                oss << "    <reg name=\"f" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i] << "\" type=\""<<type<<"\" regnum=\"" << i+33 << "\"/>\n";
+            auto reg_base_num = get_f0_offset<ARCH>();
+            auto type = iss::arch::traits<ARCH>::FLEN == 32 ? "ieee_single" : "riscv_double";
+            for(auto i = 0U; i < 32; ++i) {
+                oss << "    <reg name=\"f" << i << "\" bitsize=\"" << iss::arch::traits<ARCH>::reg_bit_widths[reg_base_num + i]
+                    << "\" type=\"" << type << "\" regnum=\"" << i + 33 << "\"/>\n";
             }
             oss << "    <reg name=\"fcsr\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\" regnum=\"103\" type int/>\n";
             oss << "    <reg name=\"fflags\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\" regnum=\"101\" type int/>\n";
@@ -420,12 +417,13 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
         std::vector<uint8_t> avail;
         data.resize(sizeof(typename traits<ARCH>::reg_t));
         avail.resize(sizeof(typename traits<ARCH>::reg_t));
-        for(auto i = 0U; i<4096; ++i) {
+        for(auto i = 0U; i < 4096; ++i) {
             typed_addr_t<iss::address_type::PHYSICAL> a(iss::access_type::DEBUG_READ, traits<ARCH>::CSR, i);
             std::fill(avail.begin(), avail.end(), 0xff);
             auto res = core->read(a, data.size(), data.data());
             if(res == iss::Ok) {
-                oss << "    <reg name=\"" << get_csr_name(i) << "\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN << "\"  type=\"int\" regnum=\"" << (i + csr_offset) << "\"/>\n";
+                oss << "    <reg name=\"" << get_csr_name(i) << "\" bitsize=\"" << iss::arch::traits<ARCH>::XLEN
+                    << "\"  type=\"int\" regnum=\"" << (i + csr_offset) << "\"/>\n";
             }
         }
         oss << "  </feature>\n";
diff --git a/src/sysc/core_complex.cpp b/src/sysc/core_complex.cpp
index 7753ddf..274cd99 100644
--- a/src/sysc/core_complex.cpp
+++ b/src/sysc/core_complex.cpp
@@ -42,7 +42,6 @@
 #include <iss/plugin/loader.h>
 #endif
 #include "sc_core_adapter_if.h"
-#include <iss/arch/tgc_mapper.h>
 #include <scc/report.h>
 #include <util/ities.h>
 #include <iostream>
@@ -208,8 +207,7 @@ core_complex<BUSWIDTH>::core_complex(sc_module_name const& name)
 }
 #endif
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::init() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::init() {
     trc = new core_trace();
     ibus.register_invalidate_direct_mem_ptr([=](uint64_t start, uint64_t end) -> void {
         auto lut_entry = fetch_lut.getEntry(start);
@@ -254,19 +252,16 @@ void core_complex<BUSWIDTH>::init() {
 #endif
 }
 
-template <unsigned int BUSWIDTH>
-core_complex<BUSWIDTH>::~core_complex() {
+template <unsigned int BUSWIDTH> core_complex<BUSWIDTH>::~core_complex() {
     delete cpu;
     delete trc;
     for(auto* p : plugin_list)
         delete p;
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::trace(sc_trace_file* trf) const {}
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::trace(sc_trace_file* trf) const {}
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::before_end_of_elaboration() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::before_end_of_elaboration() {
     SCCDEBUG(SCMOD) << "instantiating iss::arch::tgf with " << GET_PROP_VALUE(backend) << " backend";
     // cpu = scc::make_unique<core_wrapper>(this);
     cpu = new core_wrapper(this);
@@ -307,8 +302,7 @@ void core_complex<BUSWIDTH>::before_end_of_elaboration() {
     }
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::start_of_simulation() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::start_of_simulation() {
     // quantum_keeper.reset();
     if(GET_PROP_VALUE(elf_file).size() > 0) {
         istringstream is(GET_PROP_VALUE(elf_file));
@@ -331,8 +325,7 @@ void core_complex<BUSWIDTH>::start_of_simulation() {
     }
 }
 
-template <unsigned int BUSWIDTH>
-bool core_complex<BUSWIDTH>::disass_output(uint64_t pc, const std::string instr_str) {
+template <unsigned int BUSWIDTH> bool core_complex<BUSWIDTH>::disass_output(uint64_t pc, const std::string instr_str) {
     if(trc->m_db == nullptr)
         return false;
     if(trc->tr_handle.is_active())
@@ -346,8 +339,7 @@ bool core_complex<BUSWIDTH>::disass_output(uint64_t pc, const std::string instr_
     return true;
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::forward() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::forward() {
 #ifndef CWR_SYSTEMC
     set_clock_period(clk_i.read());
 #else
@@ -356,30 +348,24 @@ void core_complex<BUSWIDTH>::forward() {
 #endif
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::set_clock_period(sc_core::sc_time period) {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::set_clock_period(sc_core::sc_time period) {
     curr_clk = period;
     if(period == SC_ZERO_TIME)
         cpu->set_interrupt_execution(true);
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::rst_cb() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::rst_cb() {
     if(rst_i.read())
         cpu->set_interrupt_execution(true);
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::sw_irq_cb() { cpu->local_irq(3, sw_irq_i.read()); }
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::sw_irq_cb() { cpu->local_irq(3, sw_irq_i.read()); }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::timer_irq_cb() { cpu->local_irq(7, timer_irq_i.read()); }
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::timer_irq_cb() { cpu->local_irq(7, timer_irq_i.read()); }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::ext_irq_cb() { cpu->local_irq(11, ext_irq_i.read()); }
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::ext_irq_cb() { cpu->local_irq(11, ext_irq_i.read()); }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::local_irq_cb() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::local_irq_cb() {
     for(auto i = 0U; i < local_irq_i.size(); ++i) {
         if(local_irq_i[i].event()) {
             cpu->local_irq(16 + i, local_irq_i[i].read());
@@ -387,8 +373,7 @@ void core_complex<BUSWIDTH>::local_irq_cb() {
     }
 }
 
-template <unsigned int BUSWIDTH>
-void core_complex<BUSWIDTH>::run() {
+template <unsigned int BUSWIDTH> void core_complex<BUSWIDTH>::run() {
     wait(SC_ZERO_TIME); // separate from elaboration phase
     do {
         wait(SC_ZERO_TIME);
@@ -406,8 +391,7 @@ void core_complex<BUSWIDTH>::run() {
     sc_stop();
 }
 
-template <unsigned int BUSWIDTH>
-bool core_complex<BUSWIDTH>::read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) {
+template <unsigned int BUSWIDTH> bool core_complex<BUSWIDTH>::read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) {
     auto& dmi_lut = is_fetch ? fetch_lut : read_lut;
     auto lut_entry = dmi_lut.getEntry(addr);
     if(lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && addr + length <= lut_entry.get_end_address() + 1) {
@@ -465,8 +449,7 @@ bool core_complex<BUSWIDTH>::read_mem(uint64_t addr, unsigned length, uint8_t* c
     }
 }
 
-template <unsigned int BUSWIDTH>
-bool core_complex<BUSWIDTH>::write_mem(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <unsigned int BUSWIDTH> bool core_complex<BUSWIDTH>::write_mem(uint64_t addr, unsigned length, const uint8_t* const data) {
     auto lut_entry = write_lut.getEntry(addr);
     if(lut_entry.get_granted_access() != tlm::tlm_dmi::DMI_ACCESS_NONE && addr + length <= lut_entry.get_end_address() + 1) {
         auto offset = addr - lut_entry.get_start_address();
@@ -514,8 +497,7 @@ bool core_complex<BUSWIDTH>::write_mem(uint64_t addr, unsigned length, const uin
     }
 }
 
-template <unsigned int BUSWIDTH>
-bool core_complex<BUSWIDTH>::read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) {
+template <unsigned int BUSWIDTH> bool core_complex<BUSWIDTH>::read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) {
     tlm::tlm_generic_payload gp;
     gp.set_command(tlm::TLM_READ_COMMAND);
     gp.set_address(addr);
@@ -525,8 +507,7 @@ bool core_complex<BUSWIDTH>::read_mem_dbg(uint64_t addr, unsigned length, uint8_
     return dbus->transport_dbg(gp) == length;
 }
 
-template <unsigned int BUSWIDTH>
-bool core_complex<BUSWIDTH>::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) {
+template <unsigned int BUSWIDTH> bool core_complex<BUSWIDTH>::write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) {
     write_buf.resize(length);
     std::copy(data, data + length, write_buf.begin()); // need to copy as TLM does not guarantee data integrity
     tlm::tlm_generic_payload gp;
diff --git a/src/sysc/core_complex.h b/src/sysc/core_complex.h
index b44050f..f3c9d60 100644
--- a/src/sysc/core_complex.h
+++ b/src/sysc/core_complex.h
@@ -33,10 +33,10 @@
 #ifndef _SYSC_CORE_COMPLEX_H_
 #define _SYSC_CORE_COMPLEX_H_
 
+#include <scc/signal_opt_ports.h>
 #include <scc/tick2time.h>
 #include <scc/traceable.h>
 #include <scc/utilities.h>
-#include <scc/signal_opt_ports.h>
 #include <tlm/scc/initiator_mixin.h>
 #include <tlm/scc/scv/tlm_rec_initiator_socket.h>
 #ifdef CWR_SYSTEMC
@@ -71,28 +71,27 @@ struct core_complex_if {
 
     virtual ~core_complex_if() = default;
 
-    virtual bool read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) =0;
+    virtual bool read_mem(uint64_t addr, unsigned length, uint8_t* const data, bool is_fetch) = 0;
 
-    virtual bool write_mem(uint64_t addr, unsigned length, const uint8_t* const data)  =0;
+    virtual bool write_mem(uint64_t addr, unsigned length, const uint8_t* const data) = 0;
 
-    virtual bool read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data)  =0;
+    virtual bool read_mem_dbg(uint64_t addr, unsigned length, uint8_t* const data) = 0;
 
-    virtual bool write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data)  =0;
+    virtual bool write_mem_dbg(uint64_t addr, unsigned length, const uint8_t* const data) = 0;
 
-    virtual bool disass_output(uint64_t pc, const std::string instr)  =0;
+    virtual bool disass_output(uint64_t pc, const std::string instr) = 0;
 
-    virtual unsigned get_last_bus_cycles() =0;
+    virtual unsigned get_last_bus_cycles() = 0;
 
     //! Allow quantum keeper handling
-    virtual void sync(uint64_t) =0;
+    virtual void sync(uint64_t) = 0;
 
     virtual char const* hier_name() = 0;
 
     scc::sc_in_opt<uint64_t> mtime_i{"mtime_i"};
 };
 
-template <unsigned int BUSWIDTH = scc::LT>
-class core_complex : public sc_core::sc_module, public scc::traceable, public core_complex_if {
+template <unsigned int BUSWIDTH = scc::LT> class core_complex : public sc_core::sc_module, public scc::traceable, public core_complex_if {
 public:
     tlm::scc::initiator_mixin<tlm::tlm_initiator_socket<BUSWIDTH>> ibus{"ibus"};
 
@@ -208,9 +207,7 @@ public:
 
     void set_clock_period(sc_core::sc_time period);
 
-    char const* hier_name() override {
-        return name();
-    }
+    char const* hier_name() override { return name(); }
 
 protected:
     void before_end_of_elaboration() override;
diff --git a/src/sysc/sc_core_adapter.h b/src/sysc/sc_core_adapter.h
index f60cac4..3820980 100644
--- a/src/sysc/sc_core_adapter.h
+++ b/src/sysc/sc_core_adapter.h
@@ -55,8 +55,8 @@ public:
             s << "[p:" << lvl[this->reg.PRIV] << ";s:0x" << std::hex << std::setfill('0') << std::setw(sizeof(reg_t) * 2)
               << (reg_t)this->state.mstatus << std::dec << ";c:" << this->reg.icount + this->cycle_offset << "]";
             SCCDEBUG(owner->hier_name()) << "disass: "
-                                    << "0x" << std::setw(16) << std::right << std::setfill('0') << std::hex << pc << "\t\t" << std::setw(40)
-                                    << std::setfill(' ') << std::left << instr << s.str();
+                                         << "0x" << std::setw(16) << std::right << std::setfill('0') << std::hex << pc << "\t\t"
+                                         << std::setw(40) << std::setfill(' ') << std::left << instr << s.str();
         }
     };
 
@@ -113,7 +113,7 @@ public:
 
     iss::status read_csr(unsigned addr, reg_t& val) override {
         if((addr == iss::arch::time || addr == iss::arch::timeh)) {
-            uint64_t time_val = owner->mtime_i.get_interface()? owner->mtime_i.read():0;
+            uint64_t time_val = owner->mtime_i.get_interface() ? owner->mtime_i.read() : 0;
             if(addr == iss::arch::time) {
                 val = static_cast<reg_t>(time_val);
             } else if(addr == iss::arch::timeh) {

From 9de0aed84da0c96077ad363327209ed284985ae9 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 16:55:49 +0200
Subject: [PATCH 084/100] expands some error message

---
 src/main.cpp | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/main.cpp b/src/main.cpp
index 02ae4b0..655c2b6 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -141,7 +141,10 @@ int main(int argc, char* argv[]) {
             std::tie(cpu, vm) = f.create(isa_opt, clim["gdb-port"].as<unsigned>(), &semihosting_cb);
         }
         if(!cpu) {
-            CPPLOG(ERR) << "Could not create cpu for isa " << isa_opt << " and backend " << clim["backend"].as<std::string>() << std::endl;
+            auto list = f.get_names();
+            std::sort(std::begin(list), std::end(list));
+            CPPLOG(ERR) << "Could not create cpu for isa " << isa_opt << " and backend " << clim["backend"].as<std::string>() << "\n"
+                        << "Available implementations (core|platform|backend):\n  - " << util::join(list, "\n  - ") << std::endl;
             return 127;
         }
         if(!vm) {

From 64329cf0f6eca4d6476eb7887147bf6ea6edc53e Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 19:36:40 +0200
Subject: [PATCH 085/100] fixes use of icount vs. cycle

---
 src/iss/arch/riscv_hart_m_p.h    | 10 +++++-----
 src/iss/arch/riscv_hart_msu_vp.h | 10 +++++-----
 src/iss/arch/riscv_hart_mu_p.h   | 10 +++++-----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 70fd958..6ff1a82 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -278,7 +278,7 @@ public:
 
     void disass_output(uint64_t pc, const std::string instr) override {
         NSCLOG(INFO, LOGCAT) << fmt::format("0x{:016x}    {:40} [s:0x{:x};c:{}]", pc, instr, (reg_t)state.mstatus,
-                                            this->reg.icount + cycle_offset);
+                                            this->reg.cycle + cycle_offset);
     };
 
     iss::instrumentation_if* get_instrumentation_if() override { return &instr_if; }
@@ -311,7 +311,7 @@ protected:
 
         uint64_t get_pendig_traps() override { return arch.reg.trap_state; }
 
-        uint64_t get_total_cycles() override { return arch.reg.icount + arch.cycle_offset; }
+        uint64_t get_total_cycles() override { return arch.reg.cycle + arch.cycle_offset; }
 
         void update_last_instr_cycles(unsigned cycles) override { arch.cycle_offset += cycles - 1; }
 
@@ -908,7 +908,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_plain(unsigned addr, reg_t
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
-    auto cycle_val = this->reg.icount + cycle_offset;
+    auto cycle_val = this->reg.cycle + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
     } else if(addr == mcycleh) {
@@ -928,7 +928,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_t
             mcycle_csr = (static_cast<uint64_t>(val) << 32) + (mcycle_csr & 0xffffffff);
         }
     }
-    cycle_offset = mcycle_csr - this->reg.icount; // TODO: relying on wrap-around
+    cycle_offset = mcycle_csr - this->reg.cycle; // TODO: relying on wrap-around
     return iss::Ok;
 }
 
@@ -959,7 +959,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, reg
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
-    uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
+    uint64_t time_val = this->reg.cycle / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
     } else if(addr == timeh) {
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 233560f..b886e2b 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -328,7 +328,7 @@ public:
 
     void disass_output(uint64_t pc, const std::string instr) override {
         CLOG(INFO, disass) << fmt::format("0x{:016x}    {:40} [p:{};s:0x{:x};c:{}]", pc, instr, lvl[this->reg.PRIV], (reg_t)state.mstatus,
-                                          this->reg.icount + cycle_offset);
+                                          this->reg.cycle + cycle_offset);
     };
 
     iss::instrumentation_if* get_instrumentation_if() override { return &instr_if; }
@@ -361,7 +361,7 @@ protected:
 
         uint64_t get_pendig_traps() override { return arch.reg.trap_state; }
 
-        uint64_t get_total_cycles() override { return arch.reg.icount + arch.cycle_offset; }
+        uint64_t get_total_cycles() override { return arch.reg.cycle + arch.cycle_offset; }
 
         void update_last_instr_cycles(unsigned cycles) override { arch.cycle_offset += cycles - 1; }
 
@@ -895,7 +895,7 @@ template <typename BASE> iss::status riscv_hart_msu_vp<BASE>::write_reg(unsigned
 }
 
 template <typename BASE> iss::status riscv_hart_msu_vp<BASE>::read_cycle(unsigned addr, reg_t& val) {
-    auto cycle_val = this->reg.icount + cycle_offset;
+    auto cycle_val = this->reg.cycle + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
     } else if(addr == mcycleh) {
@@ -916,7 +916,7 @@ template <typename BASE> iss::status riscv_hart_msu_vp<BASE>::write_cycle(unsign
             mcycle_csr = (static_cast<uint64_t>(val) << 32) + (mcycle_csr & 0xffffffff);
         }
     }
-    cycle_offset = mcycle_csr - this->reg.icount; // TODO: relying on wrap-around
+    cycle_offset = mcycle_csr - this->reg.cycle; // TODO: relying on wrap-around
     return iss::Ok;
 }
 
@@ -944,7 +944,7 @@ template <typename BASE> iss::status riscv_hart_msu_vp<BASE>::write_instret(unsi
 }
 
 template <typename BASE> iss::status riscv_hart_msu_vp<BASE>::read_time(unsigned addr, reg_t& val) {
-    uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
+    uint64_t time_val = this->reg.cycle / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
     } else if(addr == timeh) {
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 617814d..974e1b4 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -305,7 +305,7 @@ public:
 
     void disass_output(uint64_t pc, const std::string instr) override {
         NSCLOG(INFO, LOGCAT) << fmt::format("0x{:016x}    {:40} [p:{};s:0x{:x};c:{}]", pc, instr, lvl[this->reg.PRIV], (reg_t)state.mstatus,
-                                            this->reg.icount + cycle_offset);
+                                            this->reg.cycle + cycle_offset);
     };
 
     iss::instrumentation_if* get_instrumentation_if() override { return &instr_if; }
@@ -338,7 +338,7 @@ protected:
 
         uint64_t get_pendig_traps() override { return arch.reg.trap_state; }
 
-        uint64_t get_total_cycles() override { return arch.reg.icount + arch.cycle_offset; }
+        uint64_t get_total_cycles() override { return arch.reg.cycle + arch.cycle_offset; }
 
         void update_last_instr_cycles(unsigned cycles) override { arch.cycle_offset += cycles - 1; }
 
@@ -1105,7 +1105,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_plain(unsigned addr, reg_
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_cycle(unsigned addr, reg_t& val) {
-    auto cycle_val = this->reg.icount + cycle_offset;
+    auto cycle_val = this->reg.cycle + cycle_offset;
     if(addr == mcycle) {
         val = static_cast<reg_t>(cycle_val);
     } else if(addr == mcycleh) {
@@ -1125,7 +1125,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_cycle(unsigned addr, reg_
             mcycle_csr = (static_cast<uint64_t>(val) << 32) + (mcycle_csr & 0xffffffff);
         }
     }
-    cycle_offset = mcycle_csr - this->reg.icount; // TODO: relying on wrap-around
+    cycle_offset = mcycle_csr - this->reg.cycle; // TODO: relying on wrap-around
     return iss::Ok;
 }
 
@@ -1156,7 +1156,7 @@ iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::write_instret(unsigned addr, re
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 iss::status riscv_hart_mu_p<BASE, FEAT, LOGCAT>::read_time(unsigned addr, reg_t& val) {
-    uint64_t time_val = this->reg.icount / (100000000 / 32768 - 1); //-> ~3052;
+    uint64_t time_val = this->reg.cycle / (100000000 / 32768 - 1); //-> ~3052;
     if(addr == time) {
         val = static_cast<reg_t>(time_val);
     } else if(addr == timeh) {

From ec1b820c18af5241cc4747a96bbde3cdcfe5b491 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Sat, 17 Aug 2024 19:36:53 +0200
Subject: [PATCH 086/100] fixes target xml generation

---
 src/iss/debugger/riscv_target_adapter.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/iss/debugger/riscv_target_adapter.h b/src/iss/debugger/riscv_target_adapter.h
index 588c0c6..a99c612 100644
--- a/src/iss/debugger/riscv_target_adapter.h
+++ b/src/iss/debugger/riscv_target_adapter.h
@@ -428,6 +428,7 @@ template <typename ARCH> status riscv_target_adapter<ARCH>::target_xml_query(std
         }
         oss << "  </feature>\n";
         oss << "</target>\n";
+        csr_xml = oss.str();
     }
     out_buf = csr_xml;
     return Ok;

From 76ea0db25d7d5d07bfd4f701f3b8758bf1c2dc0e Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Sat, 17 Aug 2024 23:15:59 +0200
Subject: [PATCH 087/100] adds newest generated vm_impl

---
 src/vm/llvm/vm_tgc5c.cpp | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 1aafb8b..9970704 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -2553,9 +2553,8 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
-        auto wait_arg0 = this->gen_const(8,1);
         std::vector<Value*> wait_args{
-            wait_arg0
+            this->gen_ext(this->gen_const(8,1), 32)
         };
         this->builder.CreateCall(this->mod->getFunction("wait"), wait_args);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
@@ -2719,7 +2718,7 @@ private:
                 csr,
                 this->builder.CreateAnd(
                    xrd,
-                   this->builder.CreateNeg(xrs1))
+                   this->builder.CreateNot(xrs1))
                 );
             }
             if(rd!=0) {

From a8f56b6e27d368c11546f1def319be1c66370d1d Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Mon, 23 Sep 2024 09:28:27 +0200
Subject: [PATCH 088/100] removes code dupication by unifying elf file read

---
 src/iss/arch/riscv_hart_common.h | 98 ++++++++++++++++++--------------
 src/iss/arch/riscv_hart_m_p.h    | 63 ++++----------------
 src/iss/arch/riscv_hart_msu_vp.h | 76 +++----------------------
 src/iss/arch/riscv_hart_mu_p.h   | 76 +++----------------------
 4 files changed, 83 insertions(+), 230 deletions(-)

diff --git a/src/iss/arch/riscv_hart_common.h b/src/iss/arch/riscv_hart_common.h
index f3b1596..471566a 100644
--- a/src/iss/arch/riscv_hart_common.h
+++ b/src/iss/arch/riscv_hart_common.h
@@ -35,6 +35,7 @@
 #ifndef _RISCV_HART_COMMON
 #define _RISCV_HART_COMMON
 
+#include "iss/vm_types.h"
 #include <cstdint>
 #include <elfio/elfio.hpp>
 #include <fmt/format.h>
@@ -314,55 +315,66 @@ struct riscv_hart_common {
     riscv_hart_common(){};
     ~riscv_hart_common(){};
     std::unordered_map<std::string, uint64_t> symbol_table;
+    uint64_t entry_address{0};
+    uint64_t tohost = tohost_dflt;
+    uint64_t fromhost = fromhost_dflt;
 
-    std::unordered_map<std::string, uint64_t> get_sym_table(std::string name) {
-        if(!symbol_table.empty())
-            return symbol_table;
-        FILE* fp = fopen(name.c_str(), "r");
-        if(fp) {
-            std::array<char, 5> buf;
-            auto n = fread(buf.data(), 1, 4, fp);
-            fclose(fp);
-            if(n != 4)
-                throw std::runtime_error("input file has insufficient size");
-            buf[4] = 0;
-            if(strcmp(buf.data() + 1, "ELF") == 0) {
-                // Create elfio reader
-                ELFIO::elfio reader;
-                // Load ELF data
-                if(!reader.load(name))
-                    throw std::runtime_error("could not process elf file");
-                // check elf properties
-                if(reader.get_type() != ET_EXEC)
-                    throw std::runtime_error("wrong elf type in file");
-                if(reader.get_machine() != EM_RISCV)
-                    throw std::runtime_error("wrong elf machine in file");
-                const auto sym_sec = reader.sections[".symtab"];
-                if(SHT_SYMTAB == sym_sec->get_type() || SHT_DYNSYM == sym_sec->get_type()) {
-                    ELFIO::symbol_section_accessor symbols(reader, sym_sec);
-                    auto sym_no = symbols.get_symbols_num();
-                    std::string name;
-                    ELFIO::Elf64_Addr value = 0;
-                    ELFIO::Elf_Xword size = 0;
-                    unsigned char bind = 0;
-                    unsigned char type = 0;
-                    ELFIO::Elf_Half section = 0;
-                    unsigned char other = 0;
-                    for(auto i = 0U; i < sym_no; ++i) {
-                        symbols.get_symbol(i, name, value, size, bind, type, section, other);
-                        if(name != "") {
-                            this->symbol_table[name] = value;
+    bool read_elf_file(std::string name, uint8_t expected_elf_class, std::function<iss::status(uint64_t, uint64_t, const uint8_t* const)> cb) {
+        // Create elfio reader
+        ELFIO::elfio reader;
+        // Load ELF data
+        if(reader.load(name)) {
+            // check elf properties
+            if(reader.get_class() != expected_elf_class)
+                return false;
+            if(reader.get_type() != ET_EXEC)
+                    return false;
+            if(reader.get_machine() != EM_RISCV)
+                return false;
+            entry_address = reader.get_entry();
+            for(const auto pseg : reader.segments) {
+                const auto fsize = pseg->get_file_size(); // 0x42c/0x0
+                const auto seg_data = pseg->get_data();
+                const auto type = pseg->get_type();
+                if(type == 1 && fsize > 0) {
+                    auto res = cb(pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
+                    if(res != iss::Ok)
+                        CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
+                }
+            }
+            const auto sym_sec = reader.sections[".symtab"];
+            if(SHT_SYMTAB == sym_sec->get_type() || SHT_DYNSYM == sym_sec->get_type()) {
+                ELFIO::symbol_section_accessor symbols(reader, sym_sec);
+                auto sym_no = symbols.get_symbols_num();
+                std::string name;
+                ELFIO::Elf64_Addr value = 0;
+                ELFIO::Elf_Xword size = 0;
+                unsigned char bind = 0;
+                unsigned char type = 0;
+                ELFIO::Elf_Half section = 0;
+                unsigned char other = 0;
+                for(auto i = 0U; i < sym_no; ++i) {
+                    symbols.get_symbol(i, name, value, size, bind, type, section, other);
+                    if(type==0 && name != "") {
+                        this->symbol_table[name] = value;
 #ifndef NDEBUG
-                            CPPLOG(DEBUG) << "Found Symbol " << name;
+                        CPPLOG(DEBUG) << "Found Symbol " << name;
 #endif
-                        }
                     }
                 }
-                return symbol_table;
+                try {
+                    tohost = symbol_table.at("tohost");
+                    try {
+                        fromhost = symbol_table.at("fromhost");
+                    } catch(std::out_of_range& e) {
+                        fromhost = tohost + 0x40;
+                    }
+                } catch(std::out_of_range& e) {
+                }
             }
-            throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file", name));
-        } else
-            throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
+            return true;
+        }
+        return false;
     };
 };
 
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 6ff1a82..cc2dcd2 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -41,6 +41,7 @@
 #include "iss/vm_if.h"
 #include "iss/vm_types.h"
 #include "riscv_hart_common.h"
+#include <elfio/elf_types.hpp>
 #include <stdexcept>
 #ifndef FMT_HEADER_ONLY
 #define FMT_HEADER_ONLY
@@ -321,7 +322,7 @@ protected:
 
         unsigned get_reg_size(unsigned num) override { return traits<BASE>::reg_bit_widths[num]; }
 
-        std::unordered_map<std::string, uint64_t> get_symbol_table(std::string name) override { return arch.get_sym_table(name); }
+        std::unordered_map<std::string, uint64_t> const& get_symbol_table(std::string name) override { return arch.symbol_table; }
 
         riscv_hart_m_p<BASE, FEAT, LOGCAT>& arch;
     };
@@ -343,8 +344,6 @@ protected:
     int64_t instret_offset{0};
     uint64_t minstret_csr{0};
     reg_t fault_data;
-    uint64_t tohost = tohost_dflt;
-    uint64_t fromhost = fromhost_dflt;
     bool tohost_lower_written = false;
     riscv_instrumentation_if instr_if;
 
@@ -573,57 +572,15 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    get_sym_table(name);
-    try {
-        tohost = symbol_table.at("tohost");
-        fromhost = symbol_table.at("fromhost");
-    } catch(std::out_of_range& e) {
+    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
+        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
+                            addr, size, data);
+
+        })) {
+        return std::make_pair(entry_address, true);
     }
-    FILE* fp = fopen(name.c_str(), "r");
-    if(fp) {
-        std::array<char, 5> buf;
-        auto n = fread(buf.data(), 1, 4, fp);
-        fclose(fp);
-        if(n != 4)
-            throw std::runtime_error("input file has insufficient size");
-        buf[4] = 0;
-        if(strcmp(buf.data() + 1, "ELF") == 0) {
-            // Create elfio reader
-            ELFIO::elfio reader;
-            // Load ELF data
-            if(!reader.load(name))
-                throw std::runtime_error("could not process elf file");
-            // check elf properties
-            if(reader.get_class() != ELFCLASS32)
-                if(sizeof(reg_t) == 4)
-                    throw std::runtime_error("wrong elf class in file");
-            if(reader.get_type() != ET_EXEC)
-                throw std::runtime_error("wrong elf type in file");
-            if(reader.get_machine() != EM_RISCV)
-                throw std::runtime_error("wrong elf machine in file");
-            auto entry = reader.get_entry();
-            for(const auto& pseg : reader.segments) {
-                const auto fsize = pseg->get_file_size(); // 0x42c/0x0
-                const auto seg_data = pseg->get_data();
-                const auto type = pseg->get_type();
-                if(type == 1 && fsize > 0) {
-                    auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                                           pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
-                    if(res != iss::Ok)
-                        CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
-                }
-            }
-            for(const auto& sec : reader.sections) {
-                if(sec->get_name() == ".tohost") {
-                    tohost = sec->get_address();
-                    fromhost = tohost + 0x40;
-                }
-            }
-            return std::make_pair(entry, true);
-        }
-        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file", name));
-    }
-    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
+    return std::make_pair(entry_address, false);
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index b886e2b..fc79aa6 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -371,7 +371,7 @@ protected:
 
         unsigned get_reg_size(unsigned num) override { return traits<BASE>::reg_bit_widths[num]; }
 
-        std::unordered_map<std::string, uint64_t> get_symbol_table(std::string name) override { return arch.get_sym_table(name); }
+        std::unordered_map<std::string, uint64_t> const& get_symbol_table(std::string name) override { return arch.symbol_table; }
 
         riscv_hart_msu_vp<BASE>& arch;
     };
@@ -393,8 +393,6 @@ protected:
     uint64_t minstret_csr{0};
     reg_t fault_data;
     std::array<vm_info, 2> vm;
-    uint64_t tohost = tohost_dflt;
-    uint64_t fromhost = fromhost_dflt;
     bool tohost_lower_written = false;
     riscv_instrumentation_if instr_if;
 
@@ -557,71 +555,15 @@ riscv_hart_msu_vp<BASE>::riscv_hart_msu_vp()
 }
 
 template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load_file(std::string name, int type) {
-    FILE* fp = fopen(name.c_str(), "r");
-    if(fp) {
-        std::array<char, 5> buf;
-        auto n = fread(buf.data(), 1, 4, fp);
-        fclose(fp);
-        if(n != 4)
-            throw std::runtime_error("input file has insufficient size");
-        buf[4] = 0;
-        if(strcmp(buf.data() + 1, "ELF") == 0) {
-            // Create elfio reader
-            ELFIO::elfio reader;
-            // Load ELF data
-            if(!reader.load(name))
-                throw std::runtime_error("could not process elf file");
-            // check elf properties
-            if(reader.get_class() != ELFCLASS32)
-                if(sizeof(reg_t) == 4)
-                    throw std::runtime_error("wrong elf class in file");
-            if(reader.get_type() != ET_EXEC)
-                throw std::runtime_error("wrong elf type in file");
-            if(reader.get_machine() != EM_RISCV)
-                throw std::runtime_error("wrong elf machine in file");
-            auto entry = reader.get_entry();
-            for(const auto pseg : reader.segments) {
-                const auto fsize = pseg->get_file_size(); // 0x42c/0x0
-                const auto seg_data = pseg->get_data();
-                const auto type = pseg->get_type();
-                if(type == 1 && fsize > 0) {
-                    auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                                           pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
-                    if(res != iss::Ok)
-                        CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
-                }
-            }
-            for(const auto sec : reader.sections) {
-                if(sec->get_name() == ".symtab") {
-                    if(SHT_SYMTAB == sec->get_type() || SHT_DYNSYM == sec->get_type()) {
-                        ELFIO::symbol_section_accessor symbols(reader, sec);
-                        auto sym_no = symbols.get_symbols_num();
-                        std::string name;
-                        ELFIO::Elf64_Addr value = 0;
-                        ELFIO::Elf_Xword size = 0;
-                        unsigned char bind = 0;
-                        unsigned char type = 0;
-                        ELFIO::Elf_Half section = 0;
-                        unsigned char other = 0;
-                        for(auto i = 0U; i < sym_no; ++i) {
-                            symbols.get_symbol(i, name, value, size, bind, type, section, other);
-                            if(name == "tohost") {
-                                tohost = value;
-                            } else if(name == "fromhost") {
-                                fromhost = value;
-                            }
-                        }
-                    }
-                } else if(sec->get_name() == ".tohost") {
-                    tohost = sec->get_address();
-                    fromhost = tohost + 0x40;
-                }
-            }
-            return std::make_pair(entry, true);
-        }
-        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file", name));
+    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
+        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
+                            addr, size, data);
+
+        })) {
+        return std::make_pair(entry_address, true);
     }
-    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
+    return std::make_pair(entry_address, false);
 }
 
 template <typename BASE>
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 974e1b4..e0774e8 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -348,7 +348,7 @@ protected:
 
         unsigned get_reg_size(unsigned num) override { return traits<BASE>::reg_bit_widths[num]; }
 
-        std::unordered_map<std::string, uint64_t> get_symbol_table(std::string name) override { return arch.get_sym_table(name); }
+        std::unordered_map<std::string, uint64_t> const& get_symbol_table(std::string name) override { return arch.symbol_table; }
 
         riscv_hart_mu_p<BASE, FEAT, LOGCAT>& arch;
     };
@@ -370,8 +370,6 @@ protected:
     int64_t instret_offset{0};
     uint64_t minstret_csr{0};
     reg_t fault_data;
-    uint64_t tohost = tohost_dflt;
-    uint64_t fromhost = fromhost_dflt;
     bool tohost_lower_written = false;
     riscv_instrumentation_if instr_if;
 
@@ -651,71 +649,15 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    FILE* fp = fopen(name.c_str(), "r");
-    if(fp) {
-        std::array<char, 5> buf;
-        auto n = fread(buf.data(), 1, 4, fp);
-        fclose(fp);
-        if(n != 4)
-            throw std::runtime_error("input file has insufficient size");
-        buf[4] = 0;
-        if(strcmp(buf.data() + 1, "ELF") == 0) {
-            // Create elfio reader
-            ELFIO::elfio reader;
-            // Load ELF data
-            if(!reader.load(name))
-                throw std::runtime_error("could not process elf file");
-            // check elf properties
-            if(reader.get_class() != ELFCLASS32)
-                if(sizeof(reg_t) == 4)
-                    throw std::runtime_error("wrong elf class in file");
-            if(reader.get_type() != ET_EXEC)
-                throw std::runtime_error("wrong elf type in file");
-            if(reader.get_machine() != EM_RISCV)
-                throw std::runtime_error("wrong elf machine in file");
-            auto entry = reader.get_entry();
-            for(const auto& pseg : reader.segments) {
-                const auto fsize = pseg->get_file_size(); // 0x42c/0x0
-                const auto seg_data = pseg->get_data();
-                const auto type = pseg->get_type();
-                if(type == 1 && fsize > 0) {
-                    auto res = this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                                           pseg->get_physical_address(), fsize, reinterpret_cast<const uint8_t* const>(seg_data));
-                    if(res != iss::Ok)
-                        CPPLOG(ERR) << "problem writing " << fsize << "bytes to 0x" << std::hex << pseg->get_physical_address();
-                }
-            }
-            for(const auto& sec : reader.sections) {
-                if(sec->get_name() == ".symtab") {
-                    if(SHT_SYMTAB == sec->get_type() || SHT_DYNSYM == sec->get_type()) {
-                        ELFIO::symbol_section_accessor symbols(reader, sec);
-                        auto sym_no = symbols.get_symbols_num();
-                        std::string name;
-                        ELFIO::Elf64_Addr value = 0;
-                        ELFIO::Elf_Xword size = 0;
-                        unsigned char bind = 0;
-                        unsigned char type = 0;
-                        ELFIO::Elf_Half section = 0;
-                        unsigned char other = 0;
-                        for(auto i = 0U; i < sym_no; ++i) {
-                            symbols.get_symbol(i, name, value, size, bind, type, section, other);
-                            if(name == "tohost") {
-                                tohost = value;
-                            } else if(name == "fromhost") {
-                                fromhost = value;
-                            }
-                        }
-                    }
-                } else if(sec->get_name() == ".tohost") {
-                    tohost = sec->get_address();
-                    fromhost = tohost + 0x40;
-                }
-            }
-            return std::make_pair(entry, true);
-        }
-        throw std::runtime_error(fmt::format("memory load file {} is not a valid elf file", name));
+    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
+        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
+                            addr, size, data);
+
+        })) {
+        return std::make_pair(entry_address, true);
     }
-    throw std::runtime_error(fmt::format("memory load file not found, check if {} is a valid file", name));
+    return std::make_pair(entry_address, false);
 }
 
 template <typename BASE, features_e FEAT, typename LOGCAT>

From f6be8ec0067073ed42649872adf5b405859f6bd7 Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Mon, 23 Sep 2024 09:29:08 +0200
Subject: [PATCH 089/100] adds elfio test utility

---
 CMakeLists.txt |  6 ++++++
 src/elfio.cpp  | 36 ++++++++++++++++++++++++++++++++++++
 2 files changed, 42 insertions(+)
 create mode 100644 src/elfio.cpp

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0d5bafc..f18d587 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -262,3 +262,9 @@ if(TARGET scc-sysc)
         INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} # headers
     )
 endif()
+
+project(elfio-test)
+find_package(Boost COMPONENTS program_options thread REQUIRED)
+
+add_executable(${PROJECT_NAME} src/elfio.cpp)
+target_link_libraries(${PROJECT_NAME} PUBLIC elfio::elfio)
diff --git a/src/elfio.cpp b/src/elfio.cpp
new file mode 100644
index 0000000..9c9bd3d
--- /dev/null
+++ b/src/elfio.cpp
@@ -0,0 +1,36 @@
+#ifdef _MSC_VER
+#define _SCL_SECURE_NO_WARNINGS
+#define ELFIO_NO_INTTYPES
+#endif
+
+#include <iostream>
+#include <elfio/elfio_dump.hpp>
+
+using namespace ELFIO;
+
+int main( int argc, char** argv )
+{
+    if ( argc != 2 ) {
+        printf( "Usage: elfdump <file_name>\n" );
+        return 1;
+    }
+
+    elfio reader;
+
+    if ( !reader.load( argv[1] ) ) {
+        printf( "File %s is not found or it is not an ELF file\n", argv[1] );
+        return 1;
+    }
+
+    dump::header( std::cout, reader );
+    dump::section_headers( std::cout, reader );
+    dump::segment_headers( std::cout, reader );
+    dump::symbol_tables( std::cout, reader );
+    dump::notes( std::cout, reader );
+    dump::modinfo( std::cout, reader );
+    dump::dynamic_tags( std::cout, reader );
+    dump::section_datas( std::cout, reader );
+    dump::segment_datas( std::cout, reader );
+
+    return 0;
+}
\ No newline at end of file

From 62768bf81e74ef35ca4eb0ef622033861a898d5e Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Mon, 23 Sep 2024 10:05:33 +0200
Subject: [PATCH 090/100] applies clang format

---
 src/iss/arch/riscv_hart_common.h |  2 +-
 src/iss/arch/riscv_hart_m_p.h    | 14 ++++++--------
 src/iss/arch/riscv_hart_msu_vp.h | 16 +++++++---------
 src/iss/arch/riscv_hart_mu_p.h   | 16 +++++++---------
 4 files changed, 21 insertions(+), 27 deletions(-)

diff --git a/src/iss/arch/riscv_hart_common.h b/src/iss/arch/riscv_hart_common.h
index 471566a..110681a 100644
--- a/src/iss/arch/riscv_hart_common.h
+++ b/src/iss/arch/riscv_hart_common.h
@@ -355,7 +355,7 @@ struct riscv_hart_common {
                 unsigned char other = 0;
                 for(auto i = 0U; i < sym_no; ++i) {
                     symbols.get_symbol(i, name, value, size, bind, type, section, other);
-                    if(type==0 && name != "") {
+                    if(name != "") {
                         this->symbol_table[name] = value;
 #ifndef NDEBUG
                         CPPLOG(DEBUG) << "Found Symbol " << name;
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index cc2dcd2..71a167a 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -572,12 +572,11 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
-        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
-            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                            addr, size, data);
-
-        })) {
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+                     [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+                         return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
+                                            data);
+                     })) {
         return std::make_pair(entry_address, true);
     }
     return std::make_pair(entry_address, false);
@@ -1327,8 +1326,7 @@ uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
         NSCLOG(INFO, LOGCAT) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                             << cause << ")"
-                             << " at address " << buffer.data() << " occurred";
+                             << cause << ")" << " at address " << buffer.data() << " occurred";
     return this->reg.NEXT_PC;
 }
 
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index fc79aa6..5d18008 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -555,12 +555,11 @@ riscv_hart_msu_vp<BASE>::riscv_hart_msu_vp()
 }
 
 template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load_file(std::string name, int type) {
-    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
-        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
-            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                            addr, size, data);
-
-        })) {
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+                     [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+                         return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
+                                            data);
+                     })) {
         return std::make_pair(entry_address, true);
     }
     return std::make_pair(entry_address, false);
@@ -1338,9 +1337,8 @@ template <typename BASE> uint64_t riscv_hart_msu_vp<BASE>::enter_trap(uint64_t f
     sprintf(buffer.data(), "0x%016lx", addr);
     if((flags & 0xffffffff) != 0xffffffff)
         CLOG(INFO, disass) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                           << cause << ")"
-                           << " at address " << buffer.data() << " occurred, changing privilege level from " << lvl[cur_priv] << " to "
-                           << lvl[new_priv];
+                           << cause << ")" << " at address " << buffer.data() << " occurred, changing privilege level from "
+                           << lvl[cur_priv] << " to " << lvl[new_priv];
     // reset trap state
     this->reg.PRIV = new_priv;
     this->reg.trap_state = 0;
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index e0774e8..017db84 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -649,12 +649,11 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    if(read_elf_file(name,sizeof(reg_t)==4?ELFCLASS32:ELFCLASS64, 
-        [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
-            return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM,
-                            addr, size, data);
-
-        })) {
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+                     [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
+                         return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
+                                            data);
+                     })) {
         return std::make_pair(entry_address, true);
     }
     return std::make_pair(entry_address, false);
@@ -1566,9 +1565,8 @@ uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
         CLOG(INFO, disass) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                           << cause << ")"
-                           << " at address " << buffer.data() << " occurred, changing privilege level from " << lvl[this->reg.PRIV]
-                           << " to " << lvl[new_priv];
+                           << cause << ")" << " at address " << buffer.data() << " occurred, changing privilege level from "
+                           << lvl[this->reg.PRIV] << " to " << lvl[new_priv];
     // reset trap state
     this->reg.PRIV = new_priv;
     this->reg.trap_state = 0;

From 2f3abf2f763f5c935876afcf4214432ba3c779fe Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 23 Sep 2024 11:51:32 +0200
Subject: [PATCH 091/100] adds namespaces for ELFIO

---
 src/iss/arch/riscv_hart_common.h | 13 +++++++------
 src/iss/arch/riscv_hart_m_p.h    |  5 +++--
 src/iss/arch/riscv_hart_msu_vp.h |  7 ++++---
 src/iss/arch/riscv_hart_mu_p.h   |  7 ++++---
 4 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/src/iss/arch/riscv_hart_common.h b/src/iss/arch/riscv_hart_common.h
index 110681a..6093909 100644
--- a/src/iss/arch/riscv_hart_common.h
+++ b/src/iss/arch/riscv_hart_common.h
@@ -319,7 +319,8 @@ struct riscv_hart_common {
     uint64_t tohost = tohost_dflt;
     uint64_t fromhost = fromhost_dflt;
 
-    bool read_elf_file(std::string name, uint8_t expected_elf_class, std::function<iss::status(uint64_t, uint64_t, const uint8_t* const)> cb) {
+    bool read_elf_file(std::string name, uint8_t expected_elf_class,
+                       std::function<iss::status(uint64_t, uint64_t, const uint8_t* const)> cb) {
         // Create elfio reader
         ELFIO::elfio reader;
         // Load ELF data
@@ -327,12 +328,12 @@ struct riscv_hart_common {
             // check elf properties
             if(reader.get_class() != expected_elf_class)
                 return false;
-            if(reader.get_type() != ET_EXEC)
-                    return false;
-            if(reader.get_machine() != EM_RISCV)
+            if(reader.get_type() != ELFIO::ET_EXEC)
+                return false;
+            if(reader.get_machine() != ELFIO::EM_RISCV)
                 return false;
             entry_address = reader.get_entry();
-            for(const auto pseg : reader.segments) {
+            for(const auto& pseg : reader.segments) {
                 const auto fsize = pseg->get_file_size(); // 0x42c/0x0
                 const auto seg_data = pseg->get_data();
                 const auto type = pseg->get_type();
@@ -343,7 +344,7 @@ struct riscv_hart_common {
                 }
             }
             const auto sym_sec = reader.sections[".symtab"];
-            if(SHT_SYMTAB == sym_sec->get_type() || SHT_DYNSYM == sym_sec->get_type()) {
+            if(ELFIO::SHT_SYMTAB == sym_sec->get_type() || ELFIO::SHT_DYNSYM == sym_sec->get_type()) {
                 ELFIO::symbol_section_accessor symbols(reader, sym_sec);
                 auto sym_no = symbols.get_symbols_num();
                 std::string name;
diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 71a167a..49adecf 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -572,7 +572,7 @@ riscv_hart_m_p<BASE, FEAT, LOGCAT>::riscv_hart_m_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_m_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFIO::ELFCLASS32 : ELFIO::ELFCLASS64,
                      [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
                          return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
                                             data);
@@ -1326,7 +1326,8 @@ uint64_t riscv_hart_m_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_t
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
         NSCLOG(INFO, LOGCAT) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                             << cause << ")" << " at address " << buffer.data() << " occurred";
+                             << cause << ")"
+                             << " at address " << buffer.data() << " occurred";
     return this->reg.NEXT_PC;
 }
 
diff --git a/src/iss/arch/riscv_hart_msu_vp.h b/src/iss/arch/riscv_hart_msu_vp.h
index 5d18008..41bc035 100644
--- a/src/iss/arch/riscv_hart_msu_vp.h
+++ b/src/iss/arch/riscv_hart_msu_vp.h
@@ -555,7 +555,7 @@ riscv_hart_msu_vp<BASE>::riscv_hart_msu_vp()
 }
 
 template <typename BASE> std::pair<uint64_t, bool> riscv_hart_msu_vp<BASE>::load_file(std::string name, int type) {
-    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFIO::ELFCLASS32 : ELFIO::ELFCLASS64,
                      [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
                          return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
                                             data);
@@ -1337,8 +1337,9 @@ template <typename BASE> uint64_t riscv_hart_msu_vp<BASE>::enter_trap(uint64_t f
     sprintf(buffer.data(), "0x%016lx", addr);
     if((flags & 0xffffffff) != 0xffffffff)
         CLOG(INFO, disass) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                           << cause << ")" << " at address " << buffer.data() << " occurred, changing privilege level from "
-                           << lvl[cur_priv] << " to " << lvl[new_priv];
+                           << cause << ")"
+                           << " at address " << buffer.data() << " occurred, changing privilege level from " << lvl[cur_priv] << " to "
+                           << lvl[new_priv];
     // reset trap state
     this->reg.PRIV = new_priv;
     this->reg.trap_state = 0;
diff --git a/src/iss/arch/riscv_hart_mu_p.h b/src/iss/arch/riscv_hart_mu_p.h
index 017db84..8620117 100644
--- a/src/iss/arch/riscv_hart_mu_p.h
+++ b/src/iss/arch/riscv_hart_mu_p.h
@@ -649,7 +649,7 @@ riscv_hart_mu_p<BASE, FEAT, LOGCAT>::riscv_hart_mu_p(feature_config cfg)
 
 template <typename BASE, features_e FEAT, typename LOGCAT>
 std::pair<uint64_t, bool> riscv_hart_mu_p<BASE, FEAT, LOGCAT>::load_file(std::string name, int type) {
-    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFCLASS32 : ELFCLASS64,
+    if(read_elf_file(name, sizeof(reg_t) == 4 ? ELFIO::ELFCLASS32 : ELFIO::ELFCLASS64,
                      [this](uint64_t addr, uint64_t size, const uint8_t* const data) -> iss::status {
                          return this->write(iss::address_type::PHYSICAL, iss::access_type::DEBUG_WRITE, traits<BASE>::MEM, addr, size,
                                             data);
@@ -1565,8 +1565,9 @@ uint64_t riscv_hart_mu_p<BASE, FEAT, LOGCAT>::enter_trap(uint64_t flags, uint64_
 #endif
     if((flags & 0xffffffff) != 0xffffffff)
         CLOG(INFO, disass) << (trap_id ? "Interrupt" : "Trap") << " with cause '" << (trap_id ? irq_str[cause] : trap_str[cause]) << "' ("
-                           << cause << ")" << " at address " << buffer.data() << " occurred, changing privilege level from "
-                           << lvl[this->reg.PRIV] << " to " << lvl[new_priv];
+                           << cause << ")"
+                           << " at address " << buffer.data() << " occurred, changing privilege level from " << lvl[this->reg.PRIV]
+                           << " to " << lvl[new_priv];
     // reset trap state
     this->reg.PRIV = new_priv;
     this->reg.trap_state = 0;

From 4c0d1c75aa3d901f3049cd22efbaf6a4b70f1ea2 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 23 Sep 2024 12:21:43 +0200
Subject: [PATCH 092/100] adds addr formatting to logging

---
 src/iss/arch/riscv_hart_m_p.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index 49adecf..f2dbde8 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -706,7 +706,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
                       << std::hex << addr;
         break;
     default:
-        CPPLOG(TRACE) << prefix << "write of " << length << " bytes @addr " << addr;
+        CPPLOG(TRACE) << prefix << "write of " << length << " bytes @addr " << std::hex << addr;
     }
 #endif
     try {

From 5f9d0beafb1a7041aea0e5a8db7458b8118730c1 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 23 Sep 2024 22:22:57 +0200
Subject: [PATCH 093/100] corrects softfloat to comply with RVD ACT

---
 src/vm/fp_functions.cpp | 51 +++++++++++++++++++++++++++--------------
 1 file changed, 34 insertions(+), 17 deletions(-)

diff --git a/src/vm/fp_functions.cpp b/src/vm/fp_functions.cpp
index de824e5..e51db7d 100644
--- a/src/vm/fp_functions.cpp
+++ b/src/vm/fp_functions.cpp
@@ -203,8 +203,8 @@ uint32_t fclass_s(uint32_t v1) {
     uA.f = a;
     uiA = uA.ui;
 
-    uint_fast16_t infOrNaN = expF32UI(uiA) == 0xFF;
-    uint_fast16_t subnormalOrZero = expF32UI(uiA) == 0;
+    bool infOrNaN = expF32UI(uiA) == 0xFF;
+    bool subnormalOrZero = expF32UI(uiA) == 0;
     bool sign = signF32UI(uiA);
     bool fracZero = fracF32UI(uiA) == 0;
     bool isNaN = isNaNF32UI(uiA);
@@ -217,9 +217,13 @@ uint32_t fclass_s(uint32_t v1) {
 }
 
 uint32_t fconv_d2f(uint64_t v1, uint8_t mode) {
+    bool isNan = isNaNF64UI(v1);
+    bool isSNaN = softfloat_isSigNaNF64UI(v1);
     softfloat_roundingMode = rmm_map.at(mode);
-    bool nan = (v1 & defaultNaNF64UI) == defaultNaNF64UI;
-    if(nan) {
+    softfloat_exceptionFlags = 0;
+    if(isNan) {
+        if(isSNaN)
+            softfloat_raiseFlags(softfloat_flag_invalid);
         return defaultNaNF32UI;
     } else {
         float32_t res = f64_to_f32(float64_t{v1});
@@ -228,11 +232,11 @@ uint32_t fconv_d2f(uint64_t v1, uint8_t mode) {
 }
 
 uint64_t fconv_f2d(uint32_t v1, uint8_t mode) {
-    bool nan = (v1 & defaultNaNF32UI) == defaultNaNF32UI;
-    if(nan) {
+    bool infOrNaN = expF32UI(v1) == 0xFF;
+    bool subnormalOrZero = expF32UI(v1) == 0;
+    if(infOrNaN || subnormalOrZero) {
         return defaultNaNF64UI;
     } else {
-        softfloat_roundingMode = rmm_map.at(mode);
         float64_t res = f32_to_f64(float32_t{v1});
         return res.v;
     }
@@ -312,22 +316,23 @@ uint64_t fcmp_d(uint64_t v1, uint64_t v2, uint32_t op) {
 }
 
 uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
+
     float64_t v1f{v1};
     softfloat_exceptionFlags = 0;
     float64_t r;
     switch(op) {
-    case 0: { // l->d, fp to int32
+    case 0: { // l from d
         int64_t res = f64_to_i64(v1f, rmm_map.at(mode), true);
         return (uint64_t)res;
     }
-    case 1: { // lu->s
+    case 1: { // lu from d
         uint64_t res = f64_to_ui64(v1f, rmm_map.at(mode), true);
         return res;
     }
-    case 2: // s->l
+    case 2: // d from l
         r = i64_to_f64(v1);
         return r.v;
-    case 3: // s->lu
+    case 3: // d from lu
         r = ui64_to_f64(v1);
         return r.v;
     }
@@ -335,12 +340,24 @@ uint64_t fcvt_d(uint64_t v1, uint32_t op, uint8_t mode) {
 }
 
 uint64_t fmadd_d(uint64_t v1, uint64_t v2, uint64_t v3, uint32_t op, uint8_t mode) {
-    // op should be {softfloat_mulAdd_subProd(2), softfloat_mulAdd_subC(1)}
+    uint64_t F64_SIGN = 1ULL << 63;
+    switch(op) {
+    case 0: // FMADD_D
+        break;
+    case 1: // FMSUB_D
+        v3 ^= F64_SIGN;
+        break;
+    case 2: // FNMADD_D
+        v1 ^= F64_SIGN;
+        v3 ^= F64_SIGN;
+        break;
+    case 3: // FNMSUB_D
+        v1 ^= F64_SIGN;
+        break;
+    }
     softfloat_roundingMode = rmm_map.at(mode);
     softfloat_exceptionFlags = 0;
-    float64_t res = softfloat_mulAddF64(v1, v2, v3, op & 0x1);
-    if(op > 1)
-        res.v ^= 1ULL << 63;
+    float64_t res = softfloat_mulAddF64(v1, v2, v3, 0);
     return res.v;
 }
 
@@ -376,8 +393,8 @@ uint64_t fclass_d(uint64_t v1) {
     uA.f = a;
     uiA = uA.ui;
 
-    uint_fast16_t infOrNaN = expF64UI(uiA) == 0x7FF;
-    uint_fast16_t subnormalOrZero = expF64UI(uiA) == 0;
+    bool infOrNaN = expF64UI(uiA) == 0x7FF;
+    bool subnormalOrZero = expF64UI(uiA) == 0;
     bool sign = signF64UI(uiA);
     bool fracZero = fracF64UI(uiA) == 0;
     bool isNaN = isNaNF64UI(uiA);

From 1fb7e8fcea2639852c03d53eb32fce8803e9f68a Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 23 Sep 2024 10:26:27 +0200
Subject: [PATCH 094/100] improves logging output

---
 src/iss/arch/riscv_hart_m_p.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/iss/arch/riscv_hart_m_p.h b/src/iss/arch/riscv_hart_m_p.h
index f2dbde8..b50da48 100644
--- a/src/iss/arch/riscv_hart_m_p.h
+++ b/src/iss/arch/riscv_hart_m_p.h
@@ -706,7 +706,7 @@ iss::status riscv_hart_m_p<BASE, FEAT, LOGCAT>::write(const address_type type, c
                       << std::hex << addr;
         break;
     default:
-        CPPLOG(TRACE) << prefix << "write of " << length << " bytes @addr " << std::hex << addr;
+        CPPLOG(TRACE) << prefix << "write of " << length << " bytes @addr 0x" << std::hex << addr;
     }
 #endif
     try {

From b45b3589facbe46d3dfe144d13a5baa6139de1e6 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Fri, 27 Sep 2024 20:03:51 +0200
Subject: [PATCH 095/100] updates templates to immediately trap when gen_trap
 is called

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 1 +
 gen_input/templates/llvm/CORENAME.cpp.gtl   | 1 +
 2 files changed, 2 insertions(+)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 7efab21..3dfb180 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -308,6 +308,7 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
+    cc.jmp(jh.trap_entry);
 }
 template <typename ARCH>
 template <typename T, typename>
diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index bcdf909..bf5828d 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -279,6 +279,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_raise_trap(uint16_t trap_id, uint16_t cause) {
     auto *TRAP_val = this->gen_const(32, 0x80 << 24 | (cause << 16) | trap_id);
     this->builder.CreateStore(TRAP_val, get_reg_ptr(traits::TRAP_STATE), true);
+    this->builder.CreateBr(this->trap_blk);
 }
 
 template <typename ARCH>

From ad604490738a9e5115804c3ab366b39c251f9137 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Fri, 27 Sep 2024 20:04:58 +0200
Subject: [PATCH 096/100] updates generated cores

---
 src/vm/asmjit/vm_tgc5c.cpp | 95 ++++++++++++++++++--------------------
 src/vm/llvm/vm_tgc5c.cpp   | 17 +++----
 src/vm/tcc/vm_tgc5c.cpp    | 44 ++++++++++++++++++
 3 files changed, 97 insertions(+), 59 deletions(-)

diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 19e10a6..791941f 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -1421,23 +1421,21 @@ private:
         }
         else{
             if(rd!=0){
-                {
-                auto label_then = cc.newLabel();
-                auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(cc, 1);
+                auto label_then11 = cc.newLabel();
+                auto label_merge11 = cc.newLabel();
+                auto tmp_reg11 = get_reg(cc, 8, false);
                 cmp(cc, gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs1), 32, true), (int16_t)sext<12>(imm));
-                cc.jl(label_then);
-                mov(cc, tmp_reg,0);
-                cc.jmp(label_merge);
-                cc.bind(label_then);
-                mov(cc, tmp_reg,1);
-                cc.bind(label_merge);
+                cc.jl(label_then11);
+                mov(cc, tmp_reg11,0);
+                cc.jmp(label_merge11);
+                cc.bind(label_then11);
+                mov(cc, tmp_reg11, 1);
+                cc.bind(label_merge11);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, tmp_reg
+                      gen_ext(cc, tmp_reg11
                       , 32, false)
                 );
-                }
             }
         }
         auto returnValue = CONT;
@@ -1484,22 +1482,20 @@ private:
         }
         else{
             if(rd!=0){
-                {
-                auto label_then = cc.newLabel();
-                auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(cc, 1);
+                auto label_then12 = cc.newLabel();
+                auto label_merge12 = cc.newLabel();
+                auto tmp_reg12 = get_reg(cc, 8, false);
                 cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), (uint32_t)((int16_t)sext<12>(imm)));
-                cc.jb(label_then);
-                mov(cc, tmp_reg,0);
-                cc.jmp(label_merge);
-                cc.bind(label_then);
-                mov(cc, tmp_reg,1);
-                cc.bind(label_merge);
+                cc.jb(label_then12);
+                mov(cc, tmp_reg12,0);
+                cc.jmp(label_merge12);
+                cc.bind(label_then12);
+                mov(cc, tmp_reg12, 1);
+                cc.bind(label_merge12);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, tmp_reg
+                      gen_ext(cc, tmp_reg12
                       , 32, false)
                 );
-                }
             }
         }
         auto returnValue = CONT;
@@ -1992,24 +1988,22 @@ private:
         }
         else{
             if(rd!=0){
-                {
-                auto label_then = cc.newLabel();
-                auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(cc, 1);
+                auto label_then13 = cc.newLabel();
+                auto label_merge13 = cc.newLabel();
+                auto tmp_reg13 = get_reg(cc, 8, false);
                 cmp(cc, gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs1), 32, true), gen_ext(cc, 
                     load_reg_from_mem(jh, traits::X0 + rs2), 32, true));
-                cc.jl(label_then);
-                mov(cc, tmp_reg,0);
-                cc.jmp(label_merge);
-                cc.bind(label_then);
-                mov(cc, tmp_reg,1);
-                cc.bind(label_merge);
+                cc.jl(label_then13);
+                mov(cc, tmp_reg13,0);
+                cc.jmp(label_merge13);
+                cc.bind(label_then13);
+                mov(cc, tmp_reg13, 1);
+                cc.bind(label_merge13);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, tmp_reg
+                      gen_ext(cc, tmp_reg13
                       , 32, false)
                 );
-                }
             }
         }
         auto returnValue = CONT;
@@ -2056,22 +2050,20 @@ private:
         }
         else{
             if(rd!=0){
-                {
-                auto label_then = cc.newLabel();
-                auto label_merge = cc.newLabel();
-                auto tmp_reg = get_reg_for(cc, 1);
+                auto label_then14 = cc.newLabel();
+                auto label_merge14 = cc.newLabel();
+                auto tmp_reg14 = get_reg(cc, 8, false);
                 cmp(cc, load_reg_from_mem(jh, traits::X0 + rs1), load_reg_from_mem(jh, traits::X0 + rs2));
-                cc.jb(label_then);
-                mov(cc, tmp_reg,0);
-                cc.jmp(label_merge);
-                cc.bind(label_then);
-                mov(cc, tmp_reg,1);
-                cc.bind(label_merge);
+                cc.jb(label_then14);
+                mov(cc, tmp_reg14,0);
+                cc.jmp(label_merge14);
+                cc.bind(label_then14);
+                mov(cc, tmp_reg14, 1);
+                cc.bind(label_merge14);
                 mov(cc, get_ptr_for(jh, traits::X0+ rd),
-                      gen_ext(cc, tmp_reg
+                      gen_ext(cc, tmp_reg14
                       , 32, false)
                 );
-                }
             }
         }
         auto returnValue = CONT;
@@ -2511,10 +2503,10 @@ private:
         gen_instr_prologue(jh);
         cc.comment("//behavior:");
         /*generate behavior*/
-        InvokeNode* call_wait;
+        InvokeNode* call_wait_15;
         jh.cc.comment("//call_wait");
-        jh.cc.invoke(&call_wait, &wait, FuncSignature::build<void, int32_t>());
-        setArg(call_wait, 0, 1);
+        jh.cc.invoke(&call_wait_15, &wait, FuncSignature::build<void, int32_t>());
+        setArg(call_wait_15, 0, 1);
         auto returnValue = CONT;
         
         gen_sync(jh, POST_SYNC, 41);
@@ -4875,6 +4867,7 @@ inline void vm_impl<ARCH>::gen_raise(jit_holder& jh, uint16_t trap_id, uint16_t
     auto tmp1 = get_reg_for(cc, traits::TRAP_STATE);
     mov(cc, tmp1, 0x80ULL << 24 | (cause << 16) | trap_id);
     mov(cc, get_ptr_for(jh, traits::TRAP_STATE), tmp1);
+    cc.jmp(jh.trap_entry);
 }
 template <typename ARCH>
 template <typename T, typename>
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 9970704..870c498 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -1490,7 +1490,7 @@ private:
                 ),
                 this->gen_const(8,1),
                 this->gen_const(8,0),
-                1), 32),
+                8), 32),
                 get_reg_ptr(rd + traits::X0), false);
             }
         }
@@ -1543,7 +1543,7 @@ private:
                 ),
                 this->gen_const(8,1),
                 this->gen_const(8,0),
-                1), 32),
+                8), 32),
                 get_reg_ptr(rd + traits::X0), false);
             }
         }
@@ -2057,7 +2057,7 @@ private:
                 ,
                 this->gen_const(8,1),
                 this->gen_const(8,0),
-                1), 32),
+                8), 32),
                 get_reg_ptr(rd + traits::X0), false);
             }
         }
@@ -2110,7 +2110,7 @@ private:
                 ,
                 this->gen_const(8,1),
                 this->gen_const(8,0),
-                1), 32),
+                8), 32),
                 get_reg_ptr(rd + traits::X0), false);
             }
         }
@@ -2553,10 +2553,10 @@ private:
         
         this->gen_instr_prologue();
         /*generate behavior*/
-        std::vector<Value*> wait_args{
+        std::vector<Value*> wait_231_args{
             this->gen_ext(this->gen_const(8,1), 32)
         };
-        this->builder.CreateCall(this->mod->getFunction("wait"), wait_args);
+        this->builder.CreateCall(this->mod->getFunction("wait"), wait_231_args);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
@@ -4897,7 +4897,7 @@ private:
             };
             this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
         }
-		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
+        this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
         this->builder.CreateStore(
@@ -4972,6 +4972,7 @@ template <typename ARCH>
 void vm_impl<ARCH>::gen_raise_trap(uint16_t trap_id, uint16_t cause) {
     auto *TRAP_val = this->gen_const(32, 0x80 << 24 | (cause << 16) | trap_id);
     this->builder.CreateStore(TRAP_val, get_reg_ptr(traits::TRAP_STATE), true);
+    this->builder.CreateBr(this->trap_blk);
 }
 
 template <typename ARCH>
@@ -5074,4 +5075,4 @@ volatile std::array<bool, 2> dummy = {
 };
 }
 }
-// clang-format on
\ No newline at end of file
+// clang-format on
diff --git a/src/vm/tcc/vm_tgc5c.cpp b/src/vm/tcc/vm_tgc5c.cpp
index 71778f6..5306c39 100644
--- a/src/vm/tcc/vm_tgc5c.cpp
+++ b/src/vm/tcc/vm_tgc5c.cpp
@@ -474,15 +474,19 @@ private:
         	tu.open_if(tu.urem(
         	   new_pc,
         	   tu.constant(static_cast<uint32_t>(traits:: INSTR_ALIGNMENT),32)));
+        	{
         	this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
+        	}
         	tu.open_else();
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.constant((uint32_t)(PC+4),32));
         	}
         	auto PC_val_v = tu.assignment("PC_val", new_pc,32);
         	tu.store(traits::NEXT_PC, PC_val_v);
         	tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(UNKNOWN_JUMP), 2));
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -521,6 +525,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
         	   tu.load(rs1 + traits::X0, 0),
         	   tu.load(rs2 + traits::X0, 0)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -530,6 +535,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -568,6 +574,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs1 + traits::X0, 0),
         	   tu.load(rs2 + traits::X0, 0)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -577,6 +584,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -615,6 +623,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SLT,
         	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -624,6 +633,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -662,6 +672,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_SGE,
         	   tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
         	   tu.ext(tu.load(rs2 + traits::X0, 0),32,true)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -671,6 +682,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -709,6 +721,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_ULT,
         	   tu.load(rs1 + traits::X0, 0),
         	   tu.load(rs2 + traits::X0, 0)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -718,6 +731,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -756,6 +770,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_UGE,
         	   tu.load(rs1 + traits::X0, 0),
         	   tu.load(rs2 + traits::X0, 0)));
+        	{
         	auto new_pc = (uint32_t)(PC+(int16_t)sext<13>(imm));
         	if(new_pc%static_cast<uint32_t>(traits:: INSTR_ALIGNMENT)){ this->gen_set_tval(tu, new_pc);
         	this->gen_raise_trap(tu, 0, 0);
@@ -765,6 +780,7 @@ private:
         		tu.store(traits::NEXT_PC, PC_val_v);
         		tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(BRANCH);
@@ -2417,6 +2433,7 @@ private:
         	if(rd!=0){ tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   divisor,
         	   tu.constant(0,8)));
+        	{
         	auto MMIN = ((uint32_t)1)<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
@@ -2425,14 +2442,21 @@ private:
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      divisor,
         	      tu.constant(- 1,8))));
+        	{
         	tu.store(rd + traits::X0, tu.constant(MMIN,32));
+        	}
         	tu.open_else();
+        	{
         	tu.store(rd + traits::X0, tu.ext((tu.sdiv(
         	   dividend,
         	   divisor)),32,false));
+        	}
         	tu.close_scope();
+        	}
         	tu.open_else();
+        	{
         	tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
+        	}
         	tu.close_scope();
         	}
         }
@@ -2471,15 +2495,19 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.udiv(
         	       tu.load(rs1 + traits::X0, 0),
         	       tu.load(rs2 + traits::X0, 0)));
         	}
+        	}
         	tu.open_else();
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.constant((uint32_t)- 1,32));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2517,6 +2545,7 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
+        	{
         	auto MMIN = (uint32_t)1<<(static_cast<uint32_t>(traits:: XLEN)-1);
         	tu.open_if(tu.logical_and(
         	   tu.icmp(ICmpInst::ICMP_EQ,
@@ -2525,20 +2554,27 @@ private:
         	   tu.icmp(ICmpInst::ICMP_EQ,
         	      tu.ext(tu.load(rs2 + traits::X0, 0),32,true),
         	      tu.constant(- 1,8))));
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.constant(0,8));
         	}
+        	}
         	tu.open_else();
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.ext((tu.srem(
         	       tu.ext(tu.load(rs1 + traits::X0, 0),32,true),
         	       tu.ext(tu.load(rs2 + traits::X0, 0),32,true))),32,false));
         	}
+        	}
         	tu.close_scope();
+        	}
         	tu.open_else();
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(CONT);
@@ -2576,15 +2612,19 @@ private:
         	tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
         	   tu.load(rs2 + traits::X0, 0),
         	   tu.constant(0,8)));
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.urem(
         	       tu.load(rs1 + traits::X0, 0),
         	       tu.load(rs2 + traits::X0, 0)));
         	}
+        	}
         	tu.open_else();
+        	{
         	if(rd!=0) {
         	    tu.store(rd + traits::X0, tu.load(rs1 + traits::X0, 0));
         	}
+        	}
         	tu.close_scope();
         }
         auto returnValue = std::make_tuple(CONT);
@@ -3185,9 +3225,11 @@ private:
         tu.open_if(tu.icmp(ICmpInst::ICMP_EQ,
            tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
+        {
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
+        }
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         
@@ -3220,9 +3262,11 @@ private:
         tu.open_if(tu.icmp(ICmpInst::ICMP_NE,
            tu.load(rs1+8 + traits::X0, 0),
            tu.constant(0,8)));
+        {
         auto PC_val_v = tu.assignment("PC_val", (uint32_t)(PC+(int16_t)sext<9>(imm)),32);
         tu.store(traits::NEXT_PC, PC_val_v);
         tu.store(traits::LAST_BRANCH, tu.constant(static_cast<int>(KNOWN_JUMP), 2));
+        }
         tu.close_scope();
         auto returnValue = std::make_tuple(BRANCH);
         

From ac818f304d4e71ce5361684c10dbc8cabf3aefaf Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Mon, 21 Oct 2024 16:42:58 +0200
Subject: [PATCH 097/100] increases verbosity incase elf loading goes wrong

---
 src/main.cpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/main.cpp b/src/main.cpp
index 655c2b6..55d3f5b 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -206,13 +206,21 @@ int main(int argc, char* argv[]) {
         if(clim.count("elf"))
             for(std::string input : clim["elf"].as<std::vector<std::string>>()) {
                 auto start_addr = vm->get_arch()->load_file(input);
-                if(start_addr.second) // FIXME: this always evaluates to true as load file always returns <sth, true>
+                if(start_addr.second)
                     start_address = start_addr.first;
+                else {
+                    LOG(ERR) << "Error occured while loading file " << input << std::endl;
+                    return 1;
+                }
             }
         for(std::string input : args) {
             auto start_addr = vm->get_arch()->load_file(input); // treat remaining arguments as elf files
-            if(start_addr.second) // FIXME: this always evaluates to true as load file always returns <sth, true>
+            if(start_addr.second)
                 start_address = start_addr.first;
+            else {
+                LOG(ERR) << "Error occured while loading file " << input << std::endl;
+                return 1;
+            }
         }
         if(clim.count("reset")) {
             auto str = clim["reset"].as<std::string>();

From be6f5791fade9906a90a5b1ff84468ddbc35ff47 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Tue, 26 Nov 2024 20:26:18 +0100
Subject: [PATCH 098/100] adds update to cyclecount after each instr for asmjit

---
 gen_input/templates/asmjit/CORENAME.cpp.gtl | 1 +
 src/vm/asmjit/vm_tgc5c.cpp                  | 1 +
 2 files changed, 2 insertions(+)

diff --git a/gen_input/templates/asmjit/CORENAME.cpp.gtl b/gen_input/templates/asmjit/CORENAME.cpp.gtl
index 3dfb180..8571d58 100644
--- a/gen_input/templates/asmjit/CORENAME.cpp.gtl
+++ b/gen_input/templates/asmjit/CORENAME.cpp.gtl
@@ -263,6 +263,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
+    cc.inc(get_ptr_for(jh, traits::CYCLE));
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){
diff --git a/src/vm/asmjit/vm_tgc5c.cpp b/src/vm/asmjit/vm_tgc5c.cpp
index 791941f..95a5d5a 100644
--- a/src/vm/asmjit/vm_tgc5c.cpp
+++ b/src/vm/asmjit/vm_tgc5c.cpp
@@ -4822,6 +4822,7 @@ void vm_impl<ARCH>::gen_instr_epilogue(jit_holder& jh) {
     cmp(cc, current_trap_state, 0);
     cc.jne(jh.trap_entry);
     cc.inc(get_ptr_for(jh, traits::ICOUNT));
+    cc.inc(get_ptr_for(jh, traits::CYCLE));
 }
 template <typename ARCH>
 void vm_impl<ARCH>::gen_block_prologue(jit_holder& jh){

From 21e1f791adbfc502f232c288cd1bcec5df0af7a0 Mon Sep 17 00:00:00 2001
From: Eyck-Alexander Jentzsch <alex@minres.com>
Date: Fri, 6 Dec 2024 09:49:02 +0100
Subject: [PATCH 099/100] corrects sysc integration template and corresponding
 file

---
 gen_input/templates/CORENAME_sysc.cpp.gtl | 24 +++++++++++------------
 src/sysc/register_tgc_c.cpp               |  4 ++--
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/gen_input/templates/CORENAME_sysc.cpp.gtl b/gen_input/templates/CORENAME_sysc.cpp.gtl
index 21cff46..6b23d0a 100644
--- a/gen_input/templates/CORENAME_sysc.cpp.gtl
+++ b/gen_input/templates/CORENAME_sysc.cpp.gtl
@@ -45,17 +45,17 @@ namespace interp {
 using namespace sysc;
 volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         }),
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|interp", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%}%>
@@ -66,17 +66,17 @@ namespace llvm {
 using namespace sysc;
 volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         }),
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%}%>
@@ -88,17 +88,17 @@ namespace tcc {
 using namespace sysc;
 volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         }),
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|tcc", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%}%>
@@ -110,17 +110,17 @@ namespace asmjit {
 using namespace sysc;
 volatile std::array<bool, ${array_count}> ${coreDef.name.toLowerCase()}_init = {
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|m_p|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         }),
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%if(coreDef.name.toLowerCase()=="tgc5d" || coreDef.name.toLowerCase()=="tgc5e") {%>,
         iss_factory::instance().register_creator("${coreDef.name.toLowerCase()}|mu_p_clic_pmp|asmjit", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-            auto* cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+            auto* cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
             auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::${coreDef.name.toLowerCase()}, (iss::arch::features_e)(iss::arch::FEAT_PMP | iss::arch::FEAT_EXT_N | iss::arch::FEAT_CLIC)>>(cc);
             return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::${coreDef.name.toLowerCase()}*>(cpu), gdb_port)}};
         })<%}%>
diff --git a/src/sysc/register_tgc_c.cpp b/src/sysc/register_tgc_c.cpp
index d2c3c49..806b874 100644
--- a/src/sysc/register_tgc_c.cpp
+++ b/src/sysc/register_tgc_c.cpp
@@ -62,12 +62,12 @@ using namespace sysc;
 volatile std::array<bool, 2> tgc_init = {
     iss_factory::instance().register_creator("tgc5c|m_p|llvm",
                                              [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+                                                 auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
                                                  auto* cpu = new sc_core_adapter<arch::riscv_hart_m_p<arch::tgc5c>>(cc);
                                                  return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
                                              }),
     iss_factory::instance().register_creator("tgc5c|mu_p|llvm", [](unsigned gdb_port, void* data) -> iss_factory::base_t {
-        auto cc = reinterpret_cast<sysc::tgfs::core_complex*>(data);
+        auto cc = reinterpret_cast<sysc::tgfs::core_complex_if*>(data);
         auto* cpu = new sc_core_adapter<arch::riscv_hart_mu_p<arch::tgc5c>>(cc);
         return {sysc::sc_cpu_ptr{cpu}, vm_ptr{create(static_cast<arch::tgc5c*>(cpu), gdb_port)}};
     })};

From a6a6f51f0bbbd0cda2d33ed7696c307ed528987b Mon Sep 17 00:00:00 2001
From: Eyck Jentzsch <eyck@minres.com>
Date: Fri, 6 Dec 2024 15:50:50 +0100
Subject: [PATCH 100/100] adds clang-format fixes

---
 src/elfio.cpp | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/elfio.cpp b/src/elfio.cpp
index 9c9bd3d..ac73293 100644
--- a/src/elfio.cpp
+++ b/src/elfio.cpp
@@ -3,34 +3,33 @@
 #define ELFIO_NO_INTTYPES
 #endif
 
-#include <iostream>
 #include <elfio/elfio_dump.hpp>
+#include <iostream>
 
 using namespace ELFIO;
 
-int main( int argc, char** argv )
-{
-    if ( argc != 2 ) {
-        printf( "Usage: elfdump <file_name>\n" );
+int main(int argc, char** argv) {
+    if(argc != 2) {
+        printf("Usage: elfdump <file_name>\n");
         return 1;
     }
 
     elfio reader;
 
-    if ( !reader.load( argv[1] ) ) {
-        printf( "File %s is not found or it is not an ELF file\n", argv[1] );
+    if(!reader.load(argv[1])) {
+        printf("File %s is not found or it is not an ELF file\n", argv[1]);
         return 1;
     }
 
-    dump::header( std::cout, reader );
-    dump::section_headers( std::cout, reader );
-    dump::segment_headers( std::cout, reader );
-    dump::symbol_tables( std::cout, reader );
-    dump::notes( std::cout, reader );
-    dump::modinfo( std::cout, reader );
-    dump::dynamic_tags( std::cout, reader );
-    dump::section_datas( std::cout, reader );
-    dump::segment_datas( std::cout, reader );
+    dump::header(std::cout, reader);
+    dump::section_headers(std::cout, reader);
+    dump::segment_headers(std::cout, reader);
+    dump::symbol_tables(std::cout, reader);
+    dump::notes(std::cout, reader);
+    dump::modinfo(std::cout, reader);
+    dump::dynamic_tags(std::cout, reader);
+    dump::section_datas(std::cout, reader);
+    dump::segment_datas(std::cout, reader);
 
     return 0;
 }
\ No newline at end of file